由于位运算直接对内存数据进行操作,不需要转成十进制,因此处理速度非常快。
按位与( Bitwise AND ),运算符号为 &
a&b 的操作的结果: a 、 b 中对应位同时为 1 ,则对应结果位也为 1 、
例如:
100100011010001010110 01111000
& 1111111 00000000
---------------------------------------------
101011 00000000
对 10101100000000 进行右移 8 位得到的是 101011 ,这就得到了 a 的 8~15 位的掩码 了。 那么根据这个启示,判断一个整数是否是处于 0-65535 之间(常用的越界判断):
用一般的 (a >= 0) && (a <= 65535) 可能要两次判断。
改用位运算只要一次:
a & ~((1 << 16)-1)
后面的常数是编译时就算好了的。其实只要算一次逻辑与就行了。
常用技巧:
1、 用于整数的奇偶性判断
一个整数 a, a & 1 这个表达式可以用来判断 a 的奇偶性。二进制的末位为 0 表示偶数,最末位为 1 表示奇数。使用 a%2 来判断奇偶性和 a & 1 是一样的作用,但是 a & 1 要快好多。
2、 判断 n 是否是 2 的正整数冪
(!(n&(n-1)) ) && n
举个例子:
如果 n = 16 = 10000 , n-1 = 1111
那么:
10000
& 1111
----------
0
再举一个例子:如果 n = 256 = 100000000 , n-1 = 11111111
那么:
100000000
&11111111
--------------
0
好!看完上面的两个小例子,相信大家都有一个感性的认识。从理论上讲,如果一个数 a 他是 2 的正整数幂,那么 a 的二进制形式必定为 1000….. (后面有 0 个或者多个 0 ),那么结论就很显然了。
3、 统计 n 中 1 的个数
朴素的统计办法是:先判断 n 的奇偶性,为奇数时计数器增加 1 ,然后将 n 右移一位,重复上面步骤,直到移位完毕。
朴素的统计办法是比较简单的,那么我们来看看比较高级的办法。
举例说明,考虑 2 位整数 n=11 ,里边有 2 个 1 ,先提取里边的偶数位 10 ,奇数位 01 ,把偶数位右移 1 位,然后与奇数位相加,因为每对奇偶位相加的和不会超过 “ 两位 ” ,所以结果中每两位保存着数 n 中 1 的个数;相应的如果 n 是四位整数 n=0111 ,先以 “ 一位 ” 为单位做奇偶位提取,然后偶数位移位(右移 1 位),相加;再以 “ 两位 ” 为单位做奇偶提取,偶数位移位(这时就需要移 2 位),相加,因为此时没对奇偶位的和不会超过 “ 四位 ” ,所以结果中保存着 n 中 1 的个数,依次类推可以得出更多位 n 的算法。整个思想类似分治法。
在这里就顺便说一下常用的二进制数:
0xAAAAAAAA =1010 1010 1010 1010 1010 1010 1010 1010
0x55555555 = 1010101 01010101 01010101 0101 0101 (奇数位为 1 ,以 1 位为单位提取奇偶位 )
0xCCCCCCCC = 11 00 11 00 11 00 11 00 11 00 11 00 11 00 11 00
0x33333333 = 11 00 11 00 11 00 11 00 11 00 11 00 11 00 11 (以 “2 位 ” 为单位提取奇偶位)
0xF0F0F0F0 = 1111 0000 1111 0000 1111 0000 1111 0000
0x0F0F0F0F = 1111 0000 1111 0000 1111 0000 1111 (以 “8 位 ” 为单位提取奇偶位 )
0xFFFF0000 = 1111111111111111 0000000000000000
0x0000FFFF = 1111111111111111 (以 “16 位 ” 为单位提取奇偶位 )
例如: 32 位无符号数的 1 的个数可以这样数:
{
// 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;
}
举个例子吧,比如说我的生日是农历 2 月 11 ,就用 211 吧,转成二进制:
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就是答案了。
4 、对于 正整数 的模运算 (注意,负数不能这么算 )
先说下比较简单的:
乘除法是很消耗时间的,只要对数左移一位就是乘以 2 ,右移一位就是除以 2,传说用位运算效率提高了60% 。
乘 2^k 众所周知: n<<k 。所以你以后还会傻傻地去敲 2566*4 的结果 10264 吗?直接 2566<<4 就搞定了,又快又准确。
除 2^k 众所周知: n>>k 。
那么 mod 2^k 呢?(对 2 的倍数取模 )
n&((1<<k)-1)
用通俗的言语来描述就是 , 对 2 的倍数取模,只要将数与 2 的倍数 -1 做按位与运算即可。
好!方便理解就举个例子吧。
思考:如果结果是要求模 2^k 时,我们真的需要每次都取模吗?
在此很容易让人想到快速幂取模法。
快速幂取模算法
经常做题目的时候会遇到要计算 a^b mod c 的情况,这时候,一个不小心就 TLE 了。那么如何解决这个问题呢?位运算来帮你吧。
首先介绍一下秦九韶算法: ( 数值分析讲得很清楚 )
把一个 n 次多项式 f(x) = a[n]x^n+a[n-1]x^(n-1)+......+a[1]x+a[0] 改写成如下形式:
f(x) = a[n]x^n+a[n-1]x^(n-1))+......+a[1]x+a[0]
= (a[n]x^(n-1)+a[n-1]x^(n-2)+......+a[1])x+a[0]
= ((a[n]x^(n-2)+a[n-1]x^(n-3)+......+a[2])x+a[1])x+a[0]
=. .....
= (......((a[n]x+a[n-1])x+a[n-2])x+......+a[1])x+a[0].
求多项式的值时,首先计算最内层括号内一次多项式的值,即
v[1]=a[n]x+a[n-1]
然后由内向外逐层计算一次多项式的值,即
v[2]=v[1]x+a[n-2]
v[3]=v[2]x+a[n-3]
......
v[n]=v[n-1]x+a[0]
这样,求 n 次多项式 f(x) 的值就转化为求 n 个一次多项式的值。
好!有了前面的基础知识,我们开始解决问题吧
由 (a × b) mod c=( (a mod c) × b) mod c.
我们可以将 b 先表示成就:
b = a[t] × 2^t + a[t-1] × 2^(t-1) + …… + a[0] × 2^0. (a[i]=[0,1]).
这样我们由 a^b 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=( (a^(2^i)) mod c)^2 mod c . 求得。
具体实现如下:
使用秦九韶算法思想进行快速幂模算法,简洁漂亮
__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;
}
http://acm.pku.edu.cn/JudgeOnline/problem?id=3070
5 、计算掩码
比如一个截取低 6 位的掩码: 0×3F
用位运算这么表示: (1 << 6) - 1
这样也非常好读取掩码,因为掩码的位数直接体现在表达式里。
按位或运算很简单,只要a和b中相应位出现1,那么a|b的结果相应位也为1。就不多说了。
6、子集
枚举出一个集合的子集。设原集合为mask,则下面的代码就可以列出它的所有子集:
for (i = mask ; i ; i = (i - 1) & mask) ;
很漂很漂亮吧。
转载:http://www.cnblogs.com/ktyanny/archive/2009/12/25/1632297.html