hdu-3071 Gcd & Lcm game---质因数分解+状态压缩+线段树

题目链接：

http://acm.hdu.edu.cn/showproblem.php?pid=3071

题目大意：

给定一个长度为n的序列m次操作，操作的种类一共有三种

• 查询
  • L :查询一个区间的所有的数的最小公倍数modp
  • G :查询一个区间的所有的数的最大公约数modp
• 修改
  • C :将给定位置的值修改成x

解题思路：

注意数据范围，每个数字不超过100，所以100以内的质因子最多25个，如果直接求解lcm和gcd的话，long long也是存不下的，所以采用存储质因子的指数，但是如果每个节点存25个值，不仅会超内存，还会超时，所以采用位运算来存每个质因子出现的次数，大于10的质因子最多出现一次，所以只需要1位即可，小于10的有2 3 5 7，2最多出现6次，即2的6次方64，3最多出现4次，5最多出现2次，7最多出现2次

所以用3个bit存2的指数，3个bit存3的指数，2个存5，2个存7，其余的只需要1位

pos数组就存的是这些素数的指数具体存在哪一位

int prime[] = {, , , , ,,,,,,,,,,,,,,,,,,,,};
int pos[] =   {,,,,,,,,,,,,,,, , , , , , , , , , };
// 0000 0000 0000 0000 0000 0000 0000 0000
//    |   |  | |
//    2   3  5 7
//用这些位表示各个素数出现的次数

求解gcd和lcm的时候，需要求出不同素因子之间的最大值和最小值，所以需要对2 3 5 7分别求解

其余的由于只有1位可以利用&运算求解，

下面自定义了Min和Max函数，求的就是x和y的gcd和lcm，这里的x和y以及求出的解并不是原来的值，而是存储的是素因子的指数表示的值

//宏定义的x和y的括号不能省略，因为参数可能是一个表达式，需要加上括号
#define _min(x, y) ((x) < (y) ? (x) : (y))//写成宏定义更快
#define _max(x, y) ((x) > (y) ? (x) : (y))
inline int Min(int x, int y)
{
    return _min(x&0x70000000, y&0x70000000) | _min(x&0x0e000000, y&0x0e000000) | _min(x&0x01800000, y&0x01800000) | _min(x&0x00600000, y&0x00600000) | ((x&0x001fffff)&(y&0x001fffff));
}
inline int Max(int x, int y)
{
    return _max(x&0x70000000, y&0x70000000) | _max(x&0x0e000000, y&0x0e000000) | _max(x&0x01800000, y&0x01800000) | _max(x&0x00600000, y&0x00600000) | ((x&0x001fffff)|(y&0x001fffff));
}

解释一下上面的_min(x&0x70000000, y&0x70000000) 0x70000000 就是16进制的数字，转化成2进制是：

0 0000 0000 0000 0000 0000 0000 0000

由上面可知第31位到28位存的是2的指数，也就是上面红色部分，用x&0x70000000，就求出了x中2的指数，而且把其他位全部置成0，y也是一样，在其中取出最小值，也就是x和y的gcd中2的指数。

同理求出3 5 7，对于后面的位都是1位，直接用&即可求出最小的指数次数，用 | 求出最大的指数次数。

还需要两个函数，一个是将数字x进行分解，将其变成上述的形式。

一个函数是根据上述形式，求出解并模上p。

inline int turn(int x)//将x质因数分解，并且将指数存在y的每一个bit上
{
    int y = ;
    for(int i = ; i <  && x > ; i++)
    {
        int cnt = ;
        while(x % prime[i] == )
        {
            x /= prime[i];
            cnt++;
        }
        y |= cnt << pos[i];
    }
    return y;
}
inline int back(int x, int p)//将所存的指数转化成原来的数字，并且模上p
{
    ll y = ;
    int k = x >> pos[];
    x ^= k << pos[];//消去2的指数
    while(k--)y = y * prime[] % p;
    k = x >> pos[];    x ^= k << pos[];    while(k--)y = y * prime[] % p;
    k = x >> pos[];    x ^= k << pos[];    while(k--)y = y * prime[] % p;
    k = x >> pos[];    x ^= k << pos[];    while(k--)y = y * prime[] % p;
    for(int i = ; i < ; i++)
        if(x & (<<pos[i]))y = y * prime[i] % p;
    return y % p;
    //此处还要模上p，因为y最开始赋值为1，没有经过while循环的话，就没有模上p，虽然y为1没关系，但是数据中有p=1的时候，此时y没有模上p
}

这两个函数很简单，但是题目很坑，有一个小细节没注意到，WA了一个多小时

就是back函数的最后一句，我本以为每次运算均已经模上了p，后来偷懒就不模上p，但是这导致我一直WA，细想后发现，最开始y = 1，如果进行while里面的乘法的话就会模上p，但是不进行while乘法，就还是原来的1，看了一眼数据范围发现，这个p可以是1，这样的话，答案就是0了，这就是导致WA的原因，为了找错误还写了个生成测试数据的代码

剩下的就是普通的线段树了

这里需要注意的是，这道题时间卡的紧，用内联函数更快，上面的back函数可以优化成下面这个样子，这样会更快。（首先就把2 3 5 7 的i次方算出来，这样可以节省300多ms，因为这几个函数调用太频繁了）

int a[]={,,,,,,};
int b[]={,,,,};
int c[]={,,};
int d[]={,,};
inline int back(int x,int p)
{
    long long y=;
    int k=x>>dpos[];y=y*a[k]%p;x^=k<<dpos[];
    k=x>>dpos[];y=y*b[k]%p;x^=k<<dpos[];
    k=x>>dpos[];y=y*c[k]%p;x^=k<<dpos[];
    k=x>>dpos[];y=y*d[k]%p;x^=k<<dpos[];
    for(int i=;i<;i++)
    if(x&(<<dpos[i])) y=y*prime[i]%p;
    return y;
}

Gcd和LCM的查询必须分开写，一开始我只写了一个函数，每次都可以求出两个值，但是一下就超时了。

最后就是这道题的代码啦

 #include<bits/stdc++.h>
 #define MID(l, r) (l + (r - l) / 2)
 #define lson(o) (o<<1)
 #define rson(o) (o<<1|1)
 #define _min(x, y) ((x) < (y) ? (x) : (y))//写成宏定义更快
 #define _max(x, y) ((x) > (y) ? (x) : (y))
 using namespace std;
 typedef long long ll;
 const int maxn = 1e6 + ;
 int prime[] = {, , , , ,,,,,,,,,,,,,,,,,,,,};
 int pos[] =   {,,,,,,,,,,,,,,, , , , , , , , , , };
 // 0000 0000 0000 0000 0000 0000 0000 0000
 //    |   |  | |
 //    2   3  5 7
 //用这些位表示各个素数出现的次数
 inline int Min(int x, int y)
 {
     return _min(x&0x70000000, y&0x70000000) | _min(x&0x0e000000, y&0x0e000000) | _min(x&0x01800000, y&0x01800000) | _min(x&0x00600000, y&0x00600000) | ((x&0x001fffff)&(y&0x001fffff));
 }
 inline int Max(int x, int y)
 {
     return _max(x&0x70000000, y&0x70000000) | _max(x&0x0e000000, y&0x0e000000) | _max(x&0x01800000, y&0x01800000) | _max(x&0x00600000, y&0x00600000) | ((x&0x001fffff)|(y&0x001fffff));
 }
 inline int turn(int x)//将x质因数分解，并且将指数存在y的每一个bit上
 {
     int y = ;
     for(int i = ; i <  && x > ; i++)
     {
         int cnt = ;
         while(x % prime[i] == )
         {
             x /= prime[i];
             cnt++;
         }
         y |= cnt << pos[i];
     }
     return y;
 }
 inline int back(int x, int p)//将所存的指数转化成原来的数字，并且模上p
 {
     ll y = ;
     int k = x >> pos[];
     x ^= k << pos[];//消去2的指数
     while(k--)y = y * prime[] % p;
     k = x >> pos[];    x ^= k << pos[];    while(k--)y = y * prime[] % p;
     k = x >> pos[];    x ^= k << pos[];    while(k--)y = y * prime[] % p;
     k = x >> pos[];    x ^= k << pos[];    while(k--)y = y * prime[] % p;
     for(int i = ; i < ; i++)
         if(x & (<<pos[i]))y = y * prime[i] % p;
     return y % p;
     //此处还要模上p，因为y最开始赋值为1，没有经过while循环的话，就没有模上p，虽然y为1没关系，但是数据中有p=1的时候，此时y没有模上p
 }
 struct node
 {
     int l, r;
     int gcd, lcm;
 }tree[maxn];
 int a[maxn];
 void build(int o, int l, int r)
 {
     tree[o].l = l, tree[o].r = r;
     if(l == r)
     {
         tree[o].gcd = tree[o].lcm = turn(a[l]);
         return;
     }
     int m = MID(l ,r), lc = lson(o), rc = rson(o);
     build(lc, l, m);
     build(rc, m + , r);
     tree[o].gcd = Min(tree[lc].gcd, tree[rc].gcd);
     tree[o].lcm = Max(tree[lc].lcm, tree[rc].lcm);
 }
 //a[p] = v;
 int p, v;
 void update(int o)
 {
     if(tree[o].l == tree[o].r)
     {
         tree[o].lcm = tree[o].gcd = turn(v);
         return;
     }
     int lc = lson(o), rc = rson(o);
     if(p <= tree[lc].r)update(lc);
     else update(rc);
     tree[o].gcd = Min(tree[lc].gcd, tree[rc].gcd);
     tree[o].lcm = Max(tree[lc].lcm, tree[rc].lcm);
 }
 int Gcd, Lcm;
 int ql, qr;
 void query_gcd(int o)
 {
     if(ql <= tree[o].l && qr >= tree[o].r)
     {
         Gcd = Min(Gcd, tree[o].gcd);
         //Lcm = Max(Lcm, tree[o].lcm);
         return;
     }
     int lc = lson(o), rc = rson(o);
     if(ql <= tree[lc].r)query_gcd(lc);
     if(qr >= tree[rc].l)query_gcd(rc);
 }
 void query_lcm(int o)
 {
     if(ql <= tree[o].l && qr >= tree[o].r)
     {
         //Gcd = Min(Gcd, tree[o].gcd);
         Lcm = Max(Lcm, tree[o].lcm);
         return;
     }
     int lc = lson(o), rc = rson(o);
     if(ql <= tree[lc].r)query_lcm(lc);
     if(qr >= tree[rc].l)query_lcm(rc);
 }
 int main()
 {
     //freopen("output.txt", "w", stdout);
     int n, q;
     while(scanf("%d%d", &n, &q) != EOF)
     {
         for(int i = ; i <= n; i++)scanf("%d", &a[i]);
         build(, , n);
         char s[];
         while(q--)
         {
             Gcd = 0x7fffffff;
             Lcm = ;
             scanf("%s", s);
             if(s[] == 'C')
             {
                 scanf("%d%d", &p, &v);
                 update();
             }
             else if(s[] == 'L')
             {
                 scanf("%d%d%d", &ql, &qr, &p);
                 query_lcm();
                 int ans = back(Lcm, p);
                 printf("%d\n", ans);
             }
             else if(s[] == 'G')
             {
                 scanf("%d%d%d", &ql, &qr, &p);
                 query_gcd();
                 int ans = back(Gcd, p);
                 printf("%d\n", ans);
             }
         }
     }
     return ;
 }