检测一个无符号数是不为2^n-1(^为幂): x&(x+1)
将最右侧0位改为1位: x | (x+1)
使用位运算的无分支代码:
计算绝对值
int abs( int x )
{
int y ;
y = x >> 31 ;
return (x^y)-y ; //or: (x+y)^y
}
符号函数:sign(x) = -1, x<0; 0, x == 0 ; 1, x > 0
int sign(int x)
{ return (x>>31) | (unsigned(-x))>>31 ; //x=-2^31时失败(^为幂)
}
不使用第三方交换x,y:
1.x ^= y ; y ^= x ; x ^= y ;
2.x = x+y ; y = x-y ; x = x-y ;
3.x = x-y ; y = y+x ; x = y-x ;
4.x = y-x ; x = y-x ; x = x+y ;
位计数,统计1位的数量:
1.
int pop(unsigned x)
{
x = x-((x>>1)&0x55555555) ;
x = (x&0x33333333) + ((x>>2) & 0x33333333 ) ; x = (x+(x>>4)) & 0x0f0f0f0f ;
x = x + (x>>8) ;
x = x + (x>>16) ;
return x & 0x0000003f ;
}
2.
int pop(unsigned x)
{
static char table[256] = { 0,1,1,2, 1,2,2,3, ...., 6,7,7,8 } ;
return table[x&0xff]+table[(x>>8)&0xff]+table[(x>>16)&0xff]+table[(x>>24)] ;
}
奇偶性计算:
x = x ^ ( x>>1 ) ;
x = x ^ ( x>>2 ) ;
x = x ^ ( x>>4 ) ;
x = x ^ ( x>>8 ) ;
x = x ^ ( x>>16 ) ;
结果中位于x最低位,对无符号x,结果的第i位是原数第i位到最左侧位的奇偶性
位反转:
unsigned rev(unsigned x)
{
x = (x & 0x55555555) << 1 | (x>>1) & 0x55555555 ;
x = (x & 0x33333333) << 2 | (x>>2) & 0x33333333 ;
x = (x & 0x0f0f0f0f) << 4 | (x>>4) & 0x0f0f0f0f ;
x = (x<<24) | ((x&0xff00)<<8) | ((x>>8) & 0xff00) | (x>>24) ;
return x ;
}
按位与(Bitwise AND),运算符号为&
a&b 的操作的结果:a、b中对应位同时为1,则对应结果位也为1、
例如:
10010001101000101011001111000
& 111111100000000
---------------------------------------------
10101100000000
对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=10101010101010101010101010101010
0x55555555 = 1010101010101010101010101010101(奇数位为1,以1位为单位提取奇偶位)
0xCCCCCCCC = 11001100110011001100110011001100
0x33333333 = 110011001100110011001100110011(以“2位”为单位提取奇偶位)
0xF0F0F0F0 = 11110000111100001111000011110000
0x0F0F0F0F = 1111000011110000111100001111(以“8位”为单位提取奇偶位)
0xFFFF0000 =11111111111111110000000000000000
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;
}
5、计算掩码
比如一个截取低6位的掩码:0×3F
用位运算这么表示:(1 << 6) - 1
这样也非常好读取掩码,因为掩码的位数直接体现在表达式里。
按位或运算很简单,只要a和b中相应位出现1,那么a|b的结果相应位也为1。就不多说了。
6、子集
枚举出一个集合的子集。设原集合为mask,则下面的代码就可以列出它的所有子集:
for (i = mask ; i ; i = (i - 1) & mask) ;
按位异或(xor)^ 操作
按位异或运算 俗称:xor运算
1、xor的基本知识
我们来看看xor运算的机理:
1001011001011----àa xor 1011010001110----àb ------------------------- 0010001000101---àc
看了上面的式子,体会到异或运算的原理了吧,就是:0和1异或0都不变,异或1则取反。很容易理解,如果b中的某位为1,那么a xor b 的作用是在a相应的位进行取反操作。用通俗易懂的语言来讲就是xor运算通常用于对二进制的特定一位进行取反操作。 我们再看到上面那个计算式子,如果得到的结果c再与b做异或运算即:
0010001000101---àc xor 1011010001110---àb ---------------------------------- 1001011001011---àd
注意到了吧,a == d 是成立的!那么我们可以得到一个结论:(a xor b) xor b = a。 同时我们还可以得到一个很诡异的swap操作: a ^= b; b ^= a; a ^= b; 自己拿起笔来模拟一下就很清楚的了。
2、xor和 not (按位否~)操作之间的关系
事实上很简单,not操作是xor操作的一个特例。取反实质上就是同1做异或操作 ~x = x^0x FFFFFFFF
3、两个比较有趣的式子:(n ^(n+1)) 和 ((n ^(n-1))+1)>>1
(1)首先来看(n ^(n+1))这个式子,假设n = 10011010, n+1 = 10011011,则:
10011010---àn xor 10011011---àn+1 ------------------------------------ 00000001---àans
如果还不能看出什么的话,再来一个例子:n = 11111111, n+1 = 100000000,则:
11110111---àn xor 11111000---àn+1 ------------------------- 000001111---àans
得到的结果为n的倒数出现第一个0的位以及后面所有的1全部变成1,其它位都为0的数。
(2)再来看看((n ^(n-1))+1)>>1这个式子 假设n = 10011010, n-1 = 10011001,则:
10011010---àn xor 10011001---àn-1 ----------------------------------------- 00000011---àans ans+1 >> 1 = 000000100 >> 1 = 000000010
看出来了吧,也就是取出n出现倒数第一个1的位及该位后面的0组成的数
4、统计n中1的奇偶性
思路:我们在按位与运算的时候学过了怎么计算一个整数中1的个数,但是我们现在用xor来解决吧:
x
=
x
^
(x
>>
1
);
x = x ^ (x >> 2 ); x = x ^ (x >> 4 ); x = x ^ (x >> 8 ); x = x ^ (x >> 16 ); return x & 1 ;
说道这里,顺便提一下怎么求解一个数n的前导0的个数,下面的代码来自Hacker's Delight
int
nlz(unsigned x)
{int n; if (x == 0 ) return ( 32 ); n = 1 ; if ((x >> 16 ) == 0 ) {n = n + 16 ; x = x << 16 ;} if ((x >> 24 ) == 0 ) {n = n + 8 ; x = x << 8 ;} if ((x >> 28 ) == 0 ) {n = n + 4 ; x = x << 4 ;} if ((x >> 30 ) == 0 ) {n = n + 2 ; x = x << 2 ;} n = n - (x >> 31 ); return n; } // 代码自己慢慢理解吧 |