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[] = {2, 3, 5, 7, 11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97};
int pos[] =   {28,25,23,21,20,19,18,17,16,15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
// 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进制是：

0111 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 = 0;for(int i = 0; i < 25 && x > 1; i++){int cnt = 0;while(x % prime[i] == 0){x /= prime[i];cnt++;}y |= cnt << pos[i];}return y;
}
inline int back(int x, int p)//将所存的指数转化成原来的数字，并且模上p
{ll y = 1;int k = x >> pos[0];x ^= k << pos[0];//消去2的指数while(k--)y = y * prime[0] % p;k = x >> pos[1];    x ^= k << pos[1];    while(k--)y = y * prime[1] % p;k = x >> pos[2];    x ^= k << pos[2];    while(k--)y = y * prime[2] % p;k = x >> pos[3];    x ^= k << pos[3];    while(k--)y = y * prime[3] % p;for(int i = 4; i < 25; i++)if(x & (1<<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[]={1,2,4,8,16,32,64};
int b[]={1,3,9,27,81};
int c[]={1,5,25};
int d[]={1,7,49};
inline int back(int x,int p)
{long long y=1;int k=x>>dpos[0];y=y*a[k]%p;x^=k<<dpos[0];k=x>>dpos[1];y=y*b[k]%p;x^=k<<dpos[1];k=x>>dpos[2];y=y*c[k]%p;x^=k<<dpos[2];k=x>>dpos[3];y=y*d[k]%p;x^=k<<dpos[3];for(int i=4;i<25;i++)if(x&(1<<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 + 10;
int prime[] = {2, 3, 5, 7, 11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97};
int pos[] =   {28,25,23,21,20,19,18,17,16,15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
// 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