洛谷 P3302 [SDOI2013]森林 可持久化线段树+lca

题目描述

小Z有一片森林，含有N个节点，每个节点上都有一个非负整数作为权值。初始的时候，森林中有M条边。

小Z希望执行T个操作，操作有两类：

Q x y k查询点x到点y路径上所有的权值中，第k小的权值是多少。此操作保证点x和点y连通，同时这两个节点的路径上至少有k个点。
L x y在点x和点y之间连接一条边。保证完成此操作后，仍然是一片森林。
为了体现程序的在线性，我们把输入数据进行了加密。设lastans为程序上一次输出的结果，初始的时候lastans为0。

对于一个输入的操作Q x y k,其真实操作为Q x^lastans y^lastans k^lastans。
对于一个输入的操作L x y，其真实操作为L x^lastans y^lastans。其中^运算符表示异或，等价于pascal中的xor运算符。
请写一个程序來帮助小Z完成这些操作。

对于所有的数据，n,m,T<= 8*10^48∗10
4
.

输入输出格式

输入格式：
第一行包含一个正整数testcase，表示当前测试数据的测试点编号。保证1<=testcase<=20。

第二行包含三个整数N，M，T，分别表示节点数、初始边数、操作数。

第三行包含N个非负整数表示 N个节点上的权值。

接下来 M行，每行包含两个整数x和 y，表示初始的时候，点x和点y 之间有一条无向边。

接下来 T行，每行描述一个操作，格式为”Q x y k“或者”L x y “，其含义见题目描述部分。

输出格式：
对于每一个第一类操作，输出一个非负整数表示答案。

输入输出样例

输入样例#1：
1
8 4 8
1 1 2 2 3 3 4 4
4 7
1 8
2 4
2 1
Q 8 7 3
Q 3 5 1
Q 10 0 0
L 5 4
L 3 2
L 0 7
Q 9 2 5
Q 6 1 6
输出样例#1：
2
2
1
4
2
说明

对于第一个操作 Q 8 7 3，此时 lastans=0，所以真实操作为Q 8^0 7^0 3^0，也即Q 8 7 3。点8到点7的路径上一共有5个点，其权值为4 1 1 2 4。
这些权值中，第三小的为 2，输出 2，lastans变为2。

对于第二个操作 Q 3 5 1 ，此时lastans=2，所以真实操作为Q 3^2 5^2 1^2 ，也即Q 1 7 3。点1到点7的路径上一共有4个点，其权值为 1 1 2 4 。
这些权值中，第三小的为2，输出2，lastans变为 2。之后的操作类似。

分析：求链上的第k大，一般可以先用主席树搞一下，发现要连边，又不用断，启发合并就可以了。可以看做每次联通块的大小至少可以增加一倍，暴力重构小的块就可以了。每个节点建一棵线段树，这棵树相当于从父亲节点加上当前节点权值这条链。

代码：
$60$分，莫名RE好烦啊

// luogu-judger-enable-o2
#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>

const int maxn=8e4+7;

using namespace std;

int last_ans=0,n,m,test,x,y,cnt,k;
int rank[maxn],ls[maxn],f[maxn][16];
int p[maxn],size[maxn],dep[maxn];
int root[maxn];

struct edge{
    int y,next;
}g[maxn*2];

struct rec{
    int x,num;
}a[maxn];

struct node{
    int l,r,data;
}t[maxn*100];

bool cmp(rec x,rec y)
{
    return x.x<y.x;
}

void add(int x,int y)
{
    g[++cnt]=(edge){y,ls[x]};
    ls[x]=cnt;
    g[++cnt]=(edge){x,ls[y]};
    ls[y]=cnt;
}

int find(int x)
{
    int y=x,root;
    while (p[x]!=0)
    {
        x=p[x];
    }
    root=x;
    x=y;
    while (p[x]!=0)
    {
        y=p[x];
        p[x]=root;
        x=y;
    }
    return root;
}

void uni(int x,int y)
{
    int u=find(x);
    int v=find(y);
    p[v]=u;
}

void ins(int &p,int q,int l,int r,int k)
{
    if (p==0) p=++cnt;
    if (l==r)
    {
        t[p].data=1;
        return;
    }
    int mid=(l+r)/2;
    if (k<=mid)
    {
        t[p].r=t[q].r;
        ins(t[p].l,t[q].l,l,mid,k);
    }
    else
    {
        t[p].l=t[q].l;
        ins(t[p].r,t[q].r,mid+1,r,k);
    }
    t[p].data=t[t[p].l].data+t[t[p].r].data;
}

int getsum(int p,int q,int a,int b,int l,int r,int k)
{
    if (l==r) return l;
    int sum=t[t[p].l].data+t[t[q].l].data-t[t[a].l].data-t[t[b].l].data;
    int mid=(l+r)/2;
    if (sum>=k) return getsum(t[p].l,t[q].l,t[a].l,t[b].l,l,mid,k);
           else return getsum(t[p].r,t[q].r,t[a].r,t[b].r,mid+1,r,k-sum);
}

void dfs(int x,int fa)
{
    size[x]=1;
    dep[x]=dep[fa]+1;
    f[x][0]=fa;
    for (int j=1;j<16;j++) f[x][j]=f[f[x][j-1]][j-1];
    ins(root[x],root[fa],0,maxn,rank[x]);
    for (int i=ls[x];i>0;i=g[i].next)
    {
        int y=g[i].y;
        if (y==fa) continue;
        dfs(y,x);
        size[x]+=size[y];
    }
}

int lca(int x,int y)
{
    if (dep[x]>dep[y]) swap(x,y);
    int c=15,k=dep[y]-dep[x];
    while (c>=0)
    {
        if (k>=1<<c) y=f[y][c],k-=1<<c;
        c--;
    }
    c=15;
    if (y==x) return x;
    while (c>=0)
    {
        if (f[x][c]!=f[y][c]) x=f[x][c],y=f[y][c];
        c--;
    }
    return f[x][0];
}

int main()
{
    scanf("%d",&n);
    scanf("%d%d%d",&n,&m,&test);
    for (int i=1;i<=n;i++)
    {
        scanf("%d",&a[i].x);
        a[i].num=i;
    }
    sort(a+1,a+n+1,cmp);
    for (int i=1;i<=n;i++) rank[a[i].num]=i;
    for (int i=1;i<=m;i++) 
    {
        scanf("%d%d",&x,&y);

        add(x,y);
        uni(x,y);
    }
    cnt=0;      
    for (int i=1;i<=n;i++)
    {
        if (p[i]==0)
        {
            dfs(i,0);
        }
    }
    char ch[1];     
    for (int i=1;i<=test;i++)
    {   
        scanf("%s",ch);
        if (ch[0]=='L')
        {
            scanf("%d%d",&x,&y);
            x^=last_ans;
            y^=last_ans;
            int u=find(x),v=find(y);
            if (size[u]<size[v]) swap(x,y),swap(u,v);
            uni(u,v);
            size[u]+=size[v];
            dfs(y,x);
        }
        else
        {
            scanf("%d%d%d",&x,&y,&k);
            x^=last_ans;
            y^=last_ans;
            k^=last_ans;
            int d=lca(x,y);
            int c=getsum(root[x],root[y],root[d],root[f[d][0]],0,maxn,k);       
            last_ans=a[c].x;
            printf("%d\n",last_ans);
        }
    }
}

$100$分：

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#define N 200005  
using namespace std;

int n,m,q,tot,cnt,last[N],dep[N],fa[N][20],size[N],f[N],root[N],val[N];
struct tree{int l,r,s;}t[N*100];
struct edge{int to,next;}e[N*2];

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

void updata(int d)
{
    t[d].s=t[t[d].l].s+t[t[d].r].s;
}

void insert(int &d,int p,int l,int r,int x)
{
    d=++tot;
    t[d].s=t[p].s;
    if (l==r)
    {
        t[d].s++;
        return;
    }
    t[d].l=t[p].l;
    t[d].r=t[p].r;
    int mid=(l+r)/2;
    if (x<=mid) insert(t[d].l,t[p].l,l,mid,x);
    else insert(t[d].r,t[p].r,mid+1,r,x);
    updata(d);
}

void dfs(int x)
{
    for (int i=1;i<=16;i++)
        fa[x][i]=0;
    for (int i=1;i<=16;i++)
        fa[x][i]=fa[fa[x][i-1]][i-1];
    insert(root[x],root[fa[x][0]],0,1000000000,val[x]);
    for (int i=last[x];i;i=e[i].next)
    {
        if (e[i].to==fa[x][0]) continue;
        dep[e[i].to]=dep[x]+1;
        fa[e[i].to][0]=x;
        dfs(e[i].to);
    }
}

int getlca(int x,int y)
{
    if (dep[x]<dep[y]) swap(x,y);
    for (int i=16;i>=0;i--)
        if (dep[fa[x][i]]>=dep[y]) x=fa[x][i];
    if (x==y) return x;
    for (int i=16;i>=0;i--)
        if (fa[x][i]!=fa[y][i])
        {
            x=fa[x][i];y=fa[y][i];
        }
    return fa[x][0];
}

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

int solveQ(int r1,int r2,int r3,int r4,int l,int r,int k)
{
    if (l==r) return l;
    int mid=(l+r)/2;
    int s=t[t[r1].l].s+t[t[r2].l].s-t[t[r3].l].s-t[t[r4].l].s;
    if (s>=k) return solveQ(t[r1].l,t[r2].l,t[r3].l,t[r4].l,l,mid,k);
    else return solveQ(t[r1].r,t[r2].r,t[r3].r,t[r4].r,mid+1,r,k-s);
}

int query(int x,int y,int z)
{
    int lca=getlca(x,y);
    return solveQ(root[x],root[y],root[lca],root[fa[lca][0]],0,1000000000,z);
}

void link(int x,int y)
{
    addedge(x,y);
    int rx=getf(x),ry=getf(y);
    if (size[rx]<size[ry])
    {
        size[ry]+=size[rx];
        f[rx]=ry;
        fa[x][0]=y;
        dep[x]=dep[y]+1;
        dfs(x);
    }else
    {
        size[rx]+=size[ry];
        f[ry]=rx;
        fa[y][0]=x;
        dep[y]=dep[x]+1;
        dfs(y);
    }
}

int main()
{ 
    int x;
    scanf("%d",&x);
    scanf("%d%d%d",&n,&m,&q);
    for (int i=1;i<=n;i++)
    {
        scanf("%d",&val[i]);
        size[i]=1;
        f[i]=i;
    }
    for (int i=1;i<=m;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        size[getf(x)]+=size[getf(y)];
        f[getf(x)]=getf(y);
        addedge(x,y);
    }
    for (int i=1;i<=n;i++)
        if (!fa[i][0]) 
        {
            dep[i]=1;
            dfs(i);
        }
    int lastans=0;
    for (int i=1;i<=q;i++)
    {
        char ch[1];
        scanf("%s",ch);
        if (ch[0]=='Q')
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            x^=lastans;y^=lastans;z^=lastans;
            lastans=query(x,y,z);
            printf("%d\n",lastans);
        }else
        {
            int x,y;
            scanf("%d%d",&x,&y);
            x^=lastans;y^=lastans;
            link(x,y);
        }
    }
    return 0;
}