[ CodeVS冲杯之路 ] P2492

　　不充钱，你怎么AC？

　　题目：http://codevs.cn/problem/2492/

　　在此先orz小胖子，教我怎么路径压缩链表，那么这样就可以在任意节点跳进链表啦（手动@LCF）

　　对于查询操作，直接树状数组（以下简称BIT）维护，修改操作就一个个暴力开方搞，再用差值单点更新BIT

　　不过这样会TLE，要加一点优化对不对，正如开头所说的路径压缩链表

　　路径压缩链表其实就是个并查集，在普通的链表里，删去两个连续的节点后会是下面这种情况，如删去2,3

　　

　　当访问 2 的时候，会跳到3，但 3 已经删除了，这就不合法了

　　于是我们要用路径压缩，搞成下面这种情况

　　

　　它是不是非常优秀，就按照并查集一样实现，具体参考代码

　　那么我们想，为什么要搞链表呢？修改的时候直接暴力扫不就行了？

　　显然 sqrt(1)=1，那么对于 1 的操作不就是无用功？那么记录下来 1 的位置，然后用链表在扫的时候把它跳转掉，因为区间可以是中间的一段，所以要用路径压缩

　　记得开long long，然后数组多开 1 个，因为若 r 为极限数据，那么跳到最后一个还会往后面跳一个，没开大的话会RE（反正多开一点好一些），记得链表的 f[n+1]=n+1 也要赋值

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
typedef long long LL;
using namespace std;

const int N=100002;
LL a[N],s[N];
int f[N],n;
namespace QuQ
{
    inline int lowbit(int x)
    {
        return x&-x;
    }
    inline void plus(int x,LL k)
    {
        while (x<=n)
        {
            a[x]+=k;
            x+=lowbit(x);
        }
    }
    inline LL sum(int x)
    {
        LL k=0;
        while (x)
        {
            k+=a[x];
            x-=lowbit(x);
        }
        return k;
    }
}
namespace OvO
{
    inline LL read()
    {
        char ch=getchar();
        LL k=0;
        while (ch<'0'||ch>'9') ch=getchar();
        while (ch>='0'&&ch<='9')
        {
            k=k*10+ch-'0';
            ch=getchar();
        }
        return k;
    }
    inline void write(LL x)
    {
        if (x>9) write(x/10);
        putchar(x%10+'0');
    }
}
inline int find(int x)
{
    return f[x]==x?x:f[x]=find(f[x]);
}
int main()
{
    int m,i,l,r;
    LL x;
    n=OvO::read();
    for (i=1;i<=n;i++)
    {
        s[i]=OvO::read();
        QuQ::plus(i,s[i]);
        f[i]=i;
    }
    f[n+1]=n+1;
    m=OvO::read();
    while (m--)
    {
        x=OvO::read();
        l=OvO::read();
        r=OvO::read();
        if (l>r) swap(l,r);
        if (x)
        {
            OvO::write(QuQ::sum(r)-QuQ::sum(l-1));
            putchar('
');
        }
        else for (l=find(l);l<=r;l=find(l+1))
        {
            x=s[l];
            x-=s[l]=sqrt(s[l]);
            if (s[l]==1) f[l]=find(l+1);
            QuQ::plus(l,-x);
        }
    }
    return 0;
}