HDU - 4027Can you answer these queries? (bit+并查集)

A lot of battleships of evil are arranged in a line before the battle. Our commander decides to use our secret weapon to eliminate the battleships. Each of the battleships can be marked a value of endurance. For every attack of our secret weapon, it could decrease the endurance of a consecutive part of battleships by make their endurance to the square root of it original value of endurance. During the series of attack of our secret weapon, the commander wants to evaluate the effect of the weapon, so he asks you for help.
You are asked to answer the queries that the sum of the endurance of a consecutive part of the battleship line.

Notice that the square root operation should be rounded down to integer.
Input
The input contains several test cases, terminated by EOF.
For each test case, the first line contains a single integer N, denoting there are N battleships of evil in a line. (1 <= N <= 100000)
The second line contains N integers Ei, indicating the endurance value of each battleship from the beginning of the line to the end. You can assume that the sum of all endurance value is less than 2 63.
The next line contains an integer M, denoting the number of actions and queries. (1 <= M <= 100000)
For the following M lines, each line contains three integers T, X and Y. The T=0 denoting the action of the secret weapon, which will decrease the endurance value of the battleships between the X-th and Y-th battleship, inclusive. The T=1 denoting the query of the commander which ask for the sum of the endurance value of the battleship between X-th and Y-th, inclusive.
Output
For each test case, print the case number at the first line. Then print one line for each query. And remember follow a blank line after each test case.
Sample Input
10
1 2 3 4 5 6 7 8 9 10
5
0 1 10
1 1 10
1 1 5
0 5 8
1 4 8
Sample Output
Case #1:
19
7
6

当时没做出来，赛后参考了打野的方法 bit+并查集的写法比较简洁。百度上基本都是线段树做的，说下自己理解

朴素我也还是用的bit 但这样肯定存在复杂度太高的问题。
更新我能一个一个开方更新然后维护bit（O(n)），查询是log
n次询问就是O(n^2)

优化就在更新这里，显然开平方是需要一个一个更新的，但是因为最多开7次开方所以每个点最多被更新7次，总的更新复杂度应该为7*n 才可以
动机就是我把那些已经为1的点 更新时候跳过
但实现起来就需要并查集，因为还是从x到y扫，如果已经开成1了就应该跳过，就用并查集把中间的点合并起来。
更新的时候 如果当前为1那么就直接跳到下一个不为1的点，中间这些都不用再更新。
第一次见到这种并查集用法，感觉涨姿势

坑点：x可以大于y
然后初始化的时候fa[i]需要初始化到n+1 不然更新的时候会死循环

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <vector>
using namespace std;
int n,m,op,x,y;
long long ad[100005],a[100005];
int fa[100005];
void add(int k,long long c){
    while(k<=n){
        ad[k]+=c;
        k+=k&(-k);
    }
}
long long ask(int k){
    long long sum=0;
    while(k>0){
        sum+=ad[k];
        k-=(k)&(-k);
    }
    return sum;
}
int find(int x){
    int r=x;
    while(fa[r]!=r) r=fa[r];
    int i=x,t;
    while(fa[i]!=r){
        t=fa[i];
        fa[i]=r;
        i=t;
    }
    return r;
}
int main(){
    freopen("in.txt","r",stdin);
    int cas=0;
    while(~scanf("%d",&n)){
        printf("Case #%d:\n",++cas);

        memset(ad,0,sizeof ad);
        for(int i=0;i<=n+1;i++) fa[i]=i;

        for(int i=1;i<=n;i++){
            scanf("%lld",&a[i]);
            add(i,a[i]);
        }
        scanf("%d",&m);

        while(m--){
            scanf("%d%d%d",&op,&x,&y);
            if(x>y) swap(x,y);
            if(op==0){
                long long sum=0;
                for(int i=find(x);i<=y;i=find(i+1)){
                    if(a[i]>1){
                        add(i,-a[i]);
                        a[i]=floor(sqrt(a[i]));
                        add(i,a[i]);
                    }else{
                        fa[i]=find(i+1);
                    }
            //  cout<<i<<endl;
                }   
            }
            else {
                printf("%lld\n",ask(y)-ask(x-1));
            }
        }
        printf("\n");
    }
    return 0;
}