bzoj 4777: [Usaco2017 Open]Switch Grass 线段树+最小生成树+set

题意

给定一张带权无向图，每个点有一个颜色，每次改变一个点的颜色，要求你在操作后输出这个图中最近异色点对之间的距离最近异色点对定义为：一对点颜色不同，且距离最小。
n,m,q<=200000

分析

有两个很重要的结论：
1、答案只可能是一条边。
2、答案必然在最小生成树上。
证明的话自己yy一下就好了。
我们可以先求出最小生成树，然后对于每个节点开一棵以颜色为下标的线段树，储存的是其所有子节点到他的边的最小值。
由于一种颜色可能有多个，于是需要在线段树的每个叶节点都开一个multiset。然后修改的话就只用修改其本身和其父亲的线段树就好了。
最后再多开一个全局的multiset记录答案。

代码

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<set>
using namespace std;

const int N=200005;
const int inf=0x3f3f3f3f;

int cnt,n,m,K,q,last[N],col[N],f[N],fa[N],val[N],sz,tot,num[N*29],root[N],lastans[N];
struct data{int x,y,val;}a[N];
struct edge{int to,next,len;}e[N*2];
struct tree{int l,r,mn;}t[N*29];
multiset<int> ans,w[N*3];

int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

bool cmp(data a,data b)
{
    return a.val<b.val;
}

int find(int x)
{
    if (f[x]==x) return x;
    f[x]=find(f[x]);
    return f[x];
}

void addedge(int u,int v,int len)
{
    e[++cnt].to=v;e[cnt].len=len;e[cnt].next=last[u];last[u]=cnt;
    e[++cnt].to=u;e[cnt].len=len;e[cnt].next=last[v];last[v]=cnt;
}

void updata(int d)
{
    t[d].mn=min(t[t[d].l].mn,t[t[d].r].mn);
}

void ins(int &d,int l,int r,int x,int y,int z)
{
    if (!d) d=++sz,t[d].mn=inf;
    if (l==r)
    {
        if (!num[d]) num[d]=++tot;
        if (z==1) w[num[d]].insert(y);
        else w[num[d]].erase(w[num[d]].lower_bound(y));
        if (!w[num[d]].empty()) t[d].mn=*(w[num[d]].begin());
        else t[d].mn=inf;
        return;
    }
    int mid=(l+r)/2;
    if (x<=mid) ins(t[d].l,l,mid,x,y,z);
    else ins(t[d].r,mid+1,r,x,y,z);
    updata(d);
}

int query(int d,int l,int r,int x,int y)
{
    if (x>y||!d) return inf;
    if (l==x&&r==y) return t[d].mn;
    int mid=(l+r)/2;
    return min(query(t[d].l,l,mid,x,min(y,mid)),query(t[d].r,mid+1,r,max(x,mid+1),y));
}

void dfs(int x)
{
    for (int i=last[x];i;i=e[i].next)
    {
        if (e[i].to==fa[x]) continue;
        fa[e[i].to]=x;val[e[i].to]=e[i].len;
        ins(root[x],1,K,col[e[i].to],e[i].len,1);
        dfs(e[i].to);
    }
    if (root[x]) ans.insert(lastans[x]=min(query(root[x],1,K,1,col[x]-1),query(root[x],1,K,col[x]+1,K)));
}

int main()
{
    n=read();m=read();K=read();q=read();
    for (int i=1;i<=m;i++) a[i].x=read(),a[i].y=read(),a[i].val=read();
    for (int i=1;i<=n;i++) col[i]=read(),f[i]=i;
    sort(a+1,a+m+1,cmp);
    for (int i=1;i<=m;i++)
    {
        int x=find(a[i].x),y=find(a[i].y);
        if (x!=y) addedge(a[i].x,a[i].y,a[i].val),f[x]=y;
    }
    t[0].mn=inf;
    dfs(1);
    while (q--)
    {
        int x=read(),y=read();
        if (root[x])
        {
            ans.erase(ans.find(lastans[x]));
            ans.insert(lastans[x]=min(query(root[x],1,K,1,y-1),query(root[x],1,K,y+1,K)));
        }
        if (fa[x])
        {
            ans.erase(ans.find(lastans[fa[x]]));
            ins(root[fa[x]],1,K,col[x],val[x],-1);
            ins(root[fa[x]],1,K,y,val[x],1);
            ans.insert(lastans[fa[x]]=min(query(root[fa[x]],1,K,1,col[fa[x]]-1),query(root[fa[x]],1,K,col[fa[x]]+1,K)));
        }
        col[x]=y;
        printf("%d\n",*(ans.begin()));
    }
    return 0;
}