BZOJ4777 [Usaco2017 Open]Switch Grass[最小生成树+权值线段树套平衡树]

标题解法是吓人的。

---

图上修改询问，不好用数据结构操作。尝试转化为树来维护。发现（不要问怎么发现的）最小生成树在这里比较行得通，因为最近异色点对一定是相邻的（很好想），所以只要看最短的一条两端连着异色点的边，而分析一下kruskal的过程，发现满足这种要求的最小边一定会被加进去（因为相邻异色点总要联通），所以不管颜色怎么修改，答案一定在最小生成树上。于是，问题转化为了一棵树。`````

修改一个点的颜色，不妨只关心他和他儿子之间的所有边。由于要查询和自己颜色不同的儿子的最小权值，与颜色有关，所以可以对于每个点，开一个动态开点的以颜色为权值的线段树维护最小边权，这样可以直接把儿子插进去，查颜色$[1,color_x)\cup(color_x,k]$的最小值，这样$color_x$变化也可以快速查询啦。但是，由于原来的颜色没有了，所以要把自己原来的颜色从父亲对应的树上删掉，为了保证其他相同颜色的权值不会被影响，所以线段树每个叶子要开一个平衡树（这里用了multiset），来维护相同颜色的各种权值，然后删除这个点就行了，然后再再把新的颜色插入到父亲里。对于每个点，到儿子的最小异色点距离如果是$f_x$，那么每次修改，父亲和自己的$f_x$会变动，求全局$f$只要在开一个multiset就好了。

空间问题：初始每个点会被父亲插入一次，插入multiset一次，总的被插入$n$个点，之后的每次修改，每次父亲插入新的颜色一次，插入新的multiset一次，空间量级$O((n+q)\log n+(n+q))$。

时间：$O((n+q)\log^2 n)$。

Note：细节注意。

Note：BZOJ跑的比较卡内存，所以把内存开小了一点才贴着上限过的。下面的code没改小。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<cmath>
 #include<queue>
 #include<set>
 #define dbg(x) cerr << #x << " = " << x <<endl
 #define dbg2(x,y) cerr<< #x <<" = "<< x <<"  "<< #y <<" = "<< y <<endl
 using namespace std;
 typedef long long ll;
 typedef double db;
 typedef pair<int,int> pii;
 template<typename T>inline T _min(T A,T B){return A<B?A:B;}
 template<typename T>inline T _max(T A,T B){return A>B?A:B;}
 template<typename T>inline char MIN(T&A,T B){return A>B?(A=B,):;}
 template<typename T>inline char MAX(T&A,T B){return A<B?(A=B,):;}
 template<typename T>inline void _swap(T&A,T&B){A^=B^=A^=B;}
 template<typename T>inline T read(T&x){
     x=;int f=;char c;while(!isdigit(c=getchar()))if(c=='-')f=;
     while(isdigit(c))x=x*+(c&),c=getchar();return f?x=-x:x;
 }
 const int N=2e5+,INF=0x3f3f3f3f;
 struct tree_edge{int nxt,to,w;}G[N<<];
 struct edge{
     int u,v,w;
     inline bool operator <(const edge&A)const{return w<A.w;}
 }e[N];
 int Head[N],tot;
 int n,m,k,q;
 inline void Addedge(int x,int y,int z){
     G[++tot].to=y,G[tot].nxt=Head[x],Head[x]=tot,G[tot].w=z;
     G[++tot].to=x,G[tot].nxt=Head[y],Head[y]=tot,G[tot].w=z;
 }
 int anc[N];
 inline int get_anc(int x){return anc[x]==x?x:anc[x]=get_anc(anc[x]);}
 inline void Kruskal(){
     sort(e+,e+m+);
     for(register int i=;i<=n;++i)anc[i]=i;
     for(register int i=;i<=m;++i)if(get_anc(e[i].u)^get_anc(e[i].v))anc[anc[e[i].u]]=anc[e[i].v],Addedge(e[i].u,e[i].v,e[i].w);
 }

 struct segment_tree{
     int lc[N*],rc[N*],minv[N*],pos[N*],cnt,mt;
     multiset<int> s[N<<];
     segment_tree(){memset(minv,0x3f,sizeof minv);}
     inline void pushup(int i){minv[i]=_min(minv[lc[i]],minv[rc[i]]);}
     void Insert(int&i,int L,int R,int c,int w){
         if(!i)i=++cnt;
         if(L==R){
             if(!pos[i])pos[i]=++mt;
             s[pos[i]].insert(w);minv[i]=*s[pos[i]].begin();
             return;
         }
         int mid=L+R>>;
         if(c<=mid)Insert(lc[i],L,mid,c,w);
         else Insert(rc[i],mid+,R,c,w);
         pushup(i);
     }
     int Query_min(int i,int L,int R,int ql,int qr){
         if(ql<=L&&qr>=R)return minv[i];
         int mid=L+R>>,ret=INF;
         if(ql<=mid)MIN(ret,Query_min(lc[i],L,mid,ql,qr));
         if(qr>mid)MIN(ret,Query_min(rc[i],mid+,R,ql,qr));
         return ret;
     }
     void Delete(int i,int L,int R,int c,int w){
         if(L==R){
             s[pos[i]].erase(s[pos[i]].find(w));
             minv[i]=s[pos[i]].empty()?INF:*s[pos[i]].begin();
             return;
         }
         int mid=L+R>>;
         if(c<=mid)Delete(lc[i],L,mid,c,w);
         else Delete(rc[i],mid+,R,c,w);
         pushup(i);
     }
 }T;

 int minv[N],fa[N],wt[N],val[N],rt[N];
 multiset<int> ans;
 #define y G[j].to
 void dfs(int x,int fat){
     fa[x]=fat;
     for(register int j=Head[x];j;j=G[j].nxt)if(y^fat)dfs(y,x),T.Insert(rt[x],,k,val[y],wt[y]=G[j].w);
     if(rt[x])minv[x]=_min(val[x]>?T.Query_min(rt[x],,k,,val[x]-):INF,val[x]<k?T.Query_min(rt[x],,k,val[x]+,k):INF),ans.insert(minv[x]);
 }
 #undef y
 inline void change_father(int x,int c){
     if(!fa[x])return;
     T.Delete(rt[fa[x]],,k,val[x],wt[x]);//dbg("delete ok");
     T.Insert(rt[fa[x]],,k,c,wt[x]);//dbg("insert ok");
     ans.erase(ans.find(minv[fa[x]]));
     ans.insert(minv[fa[x]]=_min(val[fa[x]]>?T.Query_min(rt[fa[x]],,k,,val[fa[x]]-):INF,val[fa[x]]<k?T.Query_min(rt[fa[x]],,k,val[fa[x]]+,k):INF));
 //    dbg2("new father",minv[fa[x]]);
 }
 inline void change_self(int x,int c){
     if(!rt[x])return;
     ans.erase(ans.find(minv[x]));
     ans.insert(minv[x]=_min(val[x]>?T.Query_min(rt[x],,k,,val[x]-):INF,val[x]<k?T.Query_min(rt[x],,k,val[x]+,k):INF));
 //    dbg2("new self",minv[x]);
 }
 inline void Query(){
     int x,c;
     while(q--){
         read(x),read(c);
         change_father(x,c);
         val[x]=c;
         change_self(x,c);
         printf("%d\n",*ans.begin());
     }
 }
 inline void Init(){
     read(n),read(m),read(k),read(q);
     for(register int i=;i<=m;++i)read(e[i].u),read(e[i].v),read(e[i].w);
     for(register int i=;i<=n;++i)read(val[i]);
 }

 int main(){//freopen("test.in","r",stdin);//freopen("test.ans","w",stdout);
     Init();
     Kruskal();
     dfs(,);
     Query();
     return ;
 }

总结：图上的操作题如果觉得维护困难可以尝试转化成树上问题，这时不妨就看看MST可不可以。