快速幂与快速取模算法
由于位运算直接对内存数据进行操作，不需要转成十进制，因此处理速度非常快。
按位与（Bitwise AND），运算符号为& 。a&b 的操作的结果：a、b中对应位同时为1，则对应结果位也为1。
判断一个整数是否是处于 0-65535 之间（常用的越界判断）
用一般的 (a >= 0) && (a <= 65535) 可能要两次判断。
改用位运算只要一次：
a & ~((1<< 16)-1)
或者写作:
a & (-(1<<16))
如果 0<=a <= 65535
则上面的表达式输出为0，否则不为零。
后面的常数是编译时就算好了的。其实只要算一次逻辑与就行了。
分析(32位int为例):
1<<16: 0000 0000 0000 0001 0000 0000 0000 0000
1<<16-1: 0000 0000 0000 0000 1111 1111 1111 1111
~((1<< 16)-1): 1111 1111 1111 1111 0000 0000 0000 0000
注:按照负数补码的规则，有 ~((1<< 16)-1) = -(1<<16)
如果0<=a <= 65535, 则a的二进制必然在 0000 0000 0000 0000 0000 0000 0000 0000 到 1111 1111 1111 1111 0000 0000 0000 0000之间。用1111 1111 1111 1111 0000 0000 0000 0000跟任意一个数作按位与运算，可以测试出该数的高16位是否有1存在，只要其高16位有1，就说明它要么是负数(第31位为1)，要么就是大于65535的数(第31位为0，第17~第30位中存在1)。如果测试的结果是0，说明这个数所有的1都出现在低16位，或者没有1(此时为0), 此时这个数满足0<=a <= 65535。
扩展开来，上面的做法还可以用来测试一个数是不是在0~32767(215)-1之间0~214等等。
判断一个整数的奇偶性
一个整数a, a & 1 这个表达式可以用来判断a的奇偶性。二进制的末位为0表示偶数，最末位为1表示奇数。使用a%2来判断奇偶性和a & 1是一样的作用，但是a & 1要快好多。
判断n是否是2的正整数幂
(n&(n-1))
如果n是2的正整数幂，则上述表达式的结果为0；否则不为0
一个例子：如果n = 256 = 100000000， n-1 = 11111111
那么n&(n-1)：
100000000
&11111111
--------------
0
这个特性来源于如果一个数a他是2的正整数幂，那么a 的二进制形式必定为1000…..（后面有0个或者多个0, 而a-1 = 0111 ....刚好所有的0和1都错位了。
统计n中1的个数
朴素的统计办法是：先判断n的奇偶性，为奇数时计数器增加1，然后将n右移一位，重复上面步骤，直到移位完毕。朴素的统计办法是比较简单的，那么我们来看看比较高级的办法。
举例说明，考虑2位整数 n=11，里边有2个1，先提取里边的偶数位10，奇数位01，把偶数位右移1位，然后与奇数位相加，因为每对奇偶位相加的和不会超过“两位”，所以结果中每两位保存着数n中1的个数(对11来说，先提取里边的偶数位10，奇数位01，把偶数位右移1位，然后与奇数位相加得到10,也就是2个1)；
相应的如果n是四位整数 n=0111，先以“一位”为单位做奇偶位提取，然后偶数位移位（右移1位），相加；再以“两位”为单位做奇偶提取，偶数位移位（这时就需要移2位），相加，因为此时没对奇偶位的和不会超过“四位”，所以结果中保存着n中1的个数，依次类推可以得出更多位n的算法。整个思想类似分治法。
举个实际的例子，假如我们要统计的数为1011 0111。先对其作两位两位的分组:
10 11 01 11
再将每个两位的奇偶位相加后保存到这个两位上:
1 1 0 1
+ 0 1 1 1
----------------------------
01 10 01 10
此时的结果中，每个组的结果实际上就是该组内1的个数。比如第一个组01表示第一组内有1个1， 第二组11表示表二个组内有2个1.
再对结果四四分组:
0110 0110
每组的高两位和低两位相加，将结果保存到四位中
0110 0110
01 01
+ 10 10
----------------------
0011 0011
此时每组实际表示的意义都是该组内原来有多少个1。以第一组为例，01 表示高位有1个1， 10表示低位有2个1。两个相加得到0011表示高2位和低2位一共有3个1。也就是本组内有3个1。
再接下来就是八八分组，低四位和高四位相加保存到8位里去，统计高四位和低四位有几个1:
0011
+ 0011
----------------------
0000 0110
再就是十六十六分组， 低8位和高8位相加。最终得到的答案是0000 0110 ，也就是十进制的6。统计的结果是原来的数里面有6个1（1011 0111）。
常用的二进制数：
0xAAAAAAAA=10101010101010101010101010101010
0x55555555 = 1010101010101010101010101010101（奇数位为1，以1位为单位提取奇偶位）
0xCCCCCCCC = 11001100110011001100110011001100
0x33333333 = 110011001100110011001100110011（以“2位”为单位提取奇偶位）
0xF0F0F0F0 = 11110000111100001111000011110000
0x0F0F0F0F = 1111000011110000111100001111（以“8位”为单位提取奇偶位）
0xFFFF0000 =11111111111111110000000000000000
0x0000FFFF = 1111111111111111（以“16位”为单位提取奇偶位）
计算32位无符号数的1的的代码如下：
int count_one(unsigned long n) { //0xAAAAAAAA，0x55555555分别是以“1位”为单位提取奇偶位 n = ((n & 0xAAAAAAAA) >> 1) + (n & 0x55555555); //0xCCCCCCCC，0x33333333分别是以“2位”为单位提取奇偶位 n = ((n & 0xCCCCCCCC) >> 2) + (n & 0x33333333); //0xF0F0F0F0，0x0F0F0F0F分别是以“4位”为单位提取奇偶位 n = ((n & 0xF0F0F0F0) >> 4) + (n & 0x0F0F0F0F); //0xFF00FF00，0x00FF00FF分别是以“8位”为单位提取奇偶位 n = ((n & 0xFF00FF00) >> 8) + (n & 0x00FF00FF); //0xFFFF0000，0x0000FFFF分别是以“16位”为单位提取奇偶位 n = ((n & 0xFFFF0000) >> 16) + (n & 0x0000FFFF); return n; }
n = 11010011
计算n = ((n & 0xAAAAAAAA) >> 1) + (n & 0x55555555);
得到 n = 10010010
计算n = ((n & 0xCCCCCCCC) >> 2) + (n & 0x33333333);
得到 n = 00110010
计算n = ((n & 0xF0F0F0F0) >> 4) + (n & 0x0F0F0F0F);
得到 n = 00000101 -----------------à无法再分了，那么5就是答案了。
快速幂取模算法
首先，假设要求一个数 n mod 2k, 可以使用下列公式
n mod 2k = n&((1<<k)-1)
用通俗的言语来描述就是,对2的倍数取模，只要将数与2的倍数-1做按位与运算即可。
假设要求 10 mod 4：
10: 1010
4：0100
10 mod 4 = (1010) & (0011) = 0010 = 2
直观的理解也很简单, 以22 = 4为例，它的二进制是0100。任何一个数，第三个1左边部分(包括第三个1)的如果还有1，那么这个部分必然能被0100整除。如1100 0011 其红色部分必然能被0100整除，事实上这个部分就是由0100进位进上去的。所以余数就是低于第三位的部分11。而要提取低位，最简单的就是做一个掩码2n-1。
经常做题目的时候会遇到要计算 a^b mod c 的情况，这时候，一个不小心就TLE了。那么如何解决这个问题呢？位运算来帮你吧。先给出公式:
(a ×b) mod c=( (a mod c) × b) mod c
我们可以将 b先表示成：
b = a[t] × 2t + a[t-1]× 2t-1+ …… + a[0] × 20. (a[i]=[0,1]).
这样我们由 ab mod c = a(a[t] × 2^t + a[t-1]× 2^（t-1） + …a[0] × 2^0) mod c.
然而我们求 a 2^(i+1) mod c=( (a2^i mod c)2 mod c .求得
具体实现如下：
使用秦九韶算法思想进行快速幂模算法，简洁漂亮
// 快速计算 (a ^ p) % m 的值 __int64 FastM(__int64 a, __int64 p, __int64 m) { if (p == 0) return 1; __int64 r = a % m; __int64 k = 1; while (p > 1) { if ((p & 1)!=0) { k = (k * r) % m; } r = (r * r) % m; p >>= 1; } return (r * k) % m; }
