HDU 5634 Rikka with Phi

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=5634

--------------------------------------------------------------------------------------------

官方题解上给的是用平衡树写 不过用类似的思路 也是可以用线段树去写的

操作$2$区间赋为相同值可以直接按照常规的线段树的题目去写

操作$1$是只减不增的 而且最多$log$次会减少到$1$

所以大量使用$1$操作会出现许多连续的$1$

当访问到区间都是一个值显然可以直接返回结果

而在这之前我们变可以把区间不为相同值的进行暴力取$phi$

尽管操作$2$会使区间值增加 但如果把连续的相同值算作$1$个区间的话

操作$2$每次最多只会增加$1$个区间 所以均摊下来并不会使操作$1$的复杂度增加

最终复杂度也是$O((n + m)logn)$的

 #include <cstdio>
 #include <cstring>
 #include <cmath>
 #include <algorithm>
 using namespace std;
 const int N = 1e7, L = 7e5, T = 3e5 + ;
 bool used[N + ];
 int phi[N + ], p[L];
 int a[T], flag[T << ];
 long long sum[T << ];
 int len, t, n, m;
 void getprime()
 {
     phi[] = ;
     for(int i = ; i <= N; ++i)
     {
         if(! used[i])
         {
             p[++len] = i;
             phi[i] = i - ;
         }
         for(int j = ; j <= len && i * p[j] <= N; ++j)
         {
             used[i * p[j]] = ;
             if(i % p[j] == )
             {
                 phi[i * p[j]] = phi[i] * p[j];
                 break;
             }
             else
                 phi[i * p[j]] = phi[i] * (p[j] - );
         }
     }
 }
 void build(int x, int L, int R)
 {
     if(L == R)
     {
         sum[x] = flag[x] = a[L];
         return;
     }
     int mid = (L + R) >> ;
     build(x << , L, mid);
     build(x <<  | , mid + , R);
     sum[x] = sum[x << ] + sum[x <<  | ];
     flag[x] = (flag[x << ] == flag[x <<  | ] ? flag[x << ] : );
 }
 void update2(int x, int L, int R, int tl, int tr, int y)
 {
     if(L <= tl && tr <= R)
     {
         flag[x] = y;
         sum[x] = (long long)flag[x] * (tr - tl + );
         return;
     }
     int mid = (tl + tr) >> ;
     if(flag[x])
     {
         update2(x << , tl, mid, tl, mid, flag[x]);
         update2(x <<  | , mid + , tr, mid + , tr, flag[x]);
     }
     if(L <= mid)
         update2(x << , L, R, tl, mid, y);
     if(mid < R)
         update2(x <<  | , L, R, mid + , tr, y);
     sum[x] = sum[x << ] + sum[x <<  | ];
     flag[x] = (flag[x << ] == flag[x <<  | ] ? flag[x << ] : );
 }
 void update1(int x, int L, int R, int tl, int tr)
 {
     if(flag[x] && L <= tl && tr <= R)
     {
         flag[x] = phi[flag[x]];
         sum[x] = (long long)flag[x] * (tr - tl + );
         return;
     }
     int mid = (tl + tr) >> ;
     if(flag[x])
     {
         update2(x << , tl, mid, tl, mid, flag[x]);
         update2(x <<  | , mid + , tr, mid + , tr, flag[x]);
     }
     if(L <= mid)
         update1(x << , L, R, tl, mid);
     if(mid < R)
         update1(x <<  | , L, R, mid + , tr);
     sum[x] = sum[x << ] + sum[x <<  | ];
     flag[x] = (flag[x << ] == flag[x <<  | ] ? flag[x << ] : );
 }
 long long query(int x, int L, int R, int tl, int tr)
 {
     if(L <= tl && tr <= R)
         return sum[x];
     int mid = (tl + tr) >> ;
     if(flag[x])
     {
         update2(x << , tl, mid, tl, mid, flag[x]);
         update2(x <<  | , mid + , tr, mid + , tr, flag[x]);
     }
     long long re = ;
     if(L <= mid)
         re += query(x << , L, R, tl, mid);
     if(mid < R)
         re += query(x <<  | , L, R, mid + , tr);
     return re;
 }
 int main()
 {
     getprime();
     scanf("%d", &t);
     while(t--)
     {
         scanf("%d%d", &n, &m);
         for(int i = ; i <= n; ++i)
             scanf("%d", &a[i]);
         build(, , n);
         int op, x, y, z;
         while(m--)
         {
             scanf("%d%d%d", &op, &x, &y);
             if(op == )
                 update1(, x, y, , n);
             else if(op == )
             {
                 scanf("%d", &z);
                 update2(, x, y, , n, z);
             }
             else
                 printf("%lld\n", query(, x, y, , n));
         }
     }
     return ;
 }