bzoj 4810 由乃的玉米田 - bitset - 莫队算法

由乃在自己的农田边散步，她突然发现田里的一排玉米非常的不美。这排玉米一共有N株，它们的高度参差不齐。

由乃认为玉米田不美，所以她决定出个数据结构题

 

这个题是这样的：

给你一个序列a，长度为n，有m次操作，每次询问一个区间是否可以选出两个数它们的差为x，或者询问一个区间是

否可以选出两个数它们的和为x，或者询问一个区间是否可以选出两个数它们的乘积为x ，这三个操作分别为操作1

,2,3选出的这两个数可以是同一个位置的数

Input

第一行两个数n,m

后面一行n个数表示ai

后面m行每行四个数opt l r x

opt表示这个是第几种操作，l,r表示操作的区间，x表示这次操作的x

定义c为每次的x和ai中的最大值，ai >= 0，每次的x>=2n,m,c <= 100000

Output

对于每个询问，如果可以，输出yuno，否则输出yumi

Sample Input

5 5
1 1 2 3 4
2 1 1 2
1 1 2 2
3 1 1 1
3 5 5 16
1 2 3 4

Sample Output

yuno
yumi
yuno
yuno
yumi

---

　　题目大意 (数据结构裸题不需要大意)。（这是由乃OI？）

　　显然bitset(别问我怎么知道的)。

　　然而考虑分块，MLE？所以果断否决掉。

　　是有个基于分块有很省内存的算法？莫队啊，我们只需要2个bitset和一个cnt数组就好了。

　　现在来考虑具体的操作。

　　1)区间内是否存在两个数差为x。这个很简单，bitset一个基本的应用。bitset维护一个值域，然后将所有数都减去x(相当于将这个bitset右移x位)，再看有没有数相等(新bitset按位与旧bitset得到的bitset是否存在某一位为1，调用它的函数any()就好了)

　　2)区间内是否存在两个数和为x。考虑a + b = x,加法不是很好处理，就转化成减法，得到a - (-b) = x。因为bitset不支持负数下标，把大小增大常数又变大，所以考虑用2个bitset。新的bitset维护某一个上限加上-b后的值域。查询的时候我们希望将第一个bitset右移x位，显然负数位才有价值，但是右移溢出的比特位会被直接舍去。所以考虑向左移，把右移x后，没有溢出的部分全部删去。这样的话就左移(limit - x)位，在和第二个bitset进行按位与，然后判断是否存在某一位为1。

　　3)还是bitset？想多了。。。Tag害死人啊。。值域只有1e5。是不是直接根号大暴力(枚举因子)就完事了？(然后我忘判因子了，就WA了几次)

Code

 /**
  * bzoj
  * Problem#4810
  * Accepted
  * Time:13672ms
  * Memory:4472k
  */
 #include<bits/stdc++.h>
 using namespace std;
 typedef bool boolean;

 typedef class Query {
     public:
         int opt;
         int l;
         int r;
         int x;
         int lid;
         int id;

         Query():opt(opt), l(l), r(r), x(x), lid(lid) {        }

         boolean operator < (Query b) const {
             if(lid != b.lid)    return lid < b.lid;
             return r < b.r;
         }
 }Query;

 #define limit 100001
 int n, m, cs;
 int *arr;
 bitset<> s, s1, rs;
 Query* qs;
 inline void init() {
     scanf("%d%d", &n, &m);
     arr = new int[(n + )];
     qs = new Query[(m + )];
     cs = sqrt(n + 0.5);
     for(int i = ; i <= n; i++)
         scanf("%d", arr + i);
     for(int i = ; i <= m; i++) {
         scanf("%d%d%d%d", &qs[i].opt, &qs[i].l, &qs[i].r, &qs[i].x);
         qs[i].lid = qs[i].l / cs, qs[i].id = i;
     }
 }

 boolean *res;
 int cnt[];
 inline void extends(int pos, int val) {
     cnt[arr[pos]] += val;
     if(cnt[arr[pos]] == )    s[arr[pos]] = , rs[limit - arr[pos]] = ;
     if(cnt[arr[pos]] == )    s[arr[pos]] = , rs[limit - arr[pos]] = ;
 }

 inline void solve() {
     res = new boolean[(m + )];
     sort(qs + , qs + m + );
     int mdzzl = , mdzzr = ;
     boolean aFlag = false;
     for(int i = ; i <= m; i++) {
         while(mdzzr < qs[i].r)    extends(++mdzzr, );
         while(mdzzr > qs[i].r)    extends(mdzzr--, -);
         while(mdzzl > qs[i].l)    extends(--mdzzl, );
         while(mdzzl < qs[i].l)    extends(mdzzl++, -);
         switch(qs[i].opt) {
             case :
                 s1 = (s << qs[i].x) & s;
                 res[qs[i].id] = s1.any();
                 break;
             case :
                 s1 = (s << (limit - qs[i].x)) & rs;
                 res[qs[i].id] = s1.any();
                 break;
             case :
                 aFlag = false;
                 for(int j = ; j * j <= qs[i].x; j++)
                     if((qs[i].x % j == ) && s[j] && s[qs[i].x / j]) {
                         aFlag = true;
                         break;
                     }
                 res[qs[i].id] = aFlag;
                 break;
             default:
                 break;
         }
     }
     for(int i = ; i <= m; i++)
         puts((res[i]) ? ("yuno") : ("yumi"));
 }

 int main() {
     init();
     solve();
     return ;
 }