bitset 位运算

1、 判断一个数是否是2的方幂
n > 0 && ((n & (n - 1)) == 0 )

解释((n & (n-1)) == 0)：

如果A&B==0，表示A与B的二进制形式没有在同一个位置都为1的时候。

那么本题到底啥意思？？

不妨先看下n-1是什么意思。

   令:n=1101011000(二进制,十进制也一样)，则

    n-1=1101010111。

n&(n-1)=1101010000

由此可以得出，n和n-1的低位不一样，直到有个转折点，就是借位的那个点，从这个点开始的高位，n和n-1都一样，如果高位一样这就造成一个问题，就是n和n-1在相同的位上可能会有同一个1，从而使((n & (n-1)) != 0),如果想要

((n & (n-1)) == 0)，则高位必须全为0，这样就没有相同的1。

所以n是2的幂或0

 

public class Solution {
    public boolean isPowerOfTwo(int n) {
         return (n&(n-1))==0&&n>0;
     }
 }

 

 

　①、二进制数 n 变成 n-1 后，如果最后一位是 0，将向前一位借 2，2-1=1。最后一位为1。如果前一位为0，将继续向前一位借2，加上本身少掉的1.则变为1。一直遇到1。减为0.

所以 二进制 xxxx10000 - 1 = xxxx01111

　　②、n&n-1

　　　　按照上述 n=xxxx10000，n-1=xxxx01111

　　　　xxxx10000

　　    & xxxx01111

-----------------------------------------

　　　　xxxx0000

可以看到将原来的最右边的1变为0了。重复这个操作，每一次 n 最右边的 1 少一个。从而统计 n 中的 1 的个数

 

 

public static int hammingWeight(int n) {
        int count=0;
        int t=n;
        while(t!=0){ 
            t=t&(t-1);
            count++;
        }
        return count; 
    }

 

3. 计算N!的质因数2的个数。
容易得出N!质因数2的个数 = [N / 2] + [N / 4] + [N / 8] + ….
下面通过一个简单的例子来推导一下过程：N = 10101(二进制表示）
现在我们跟踪最高位的1，不考虑其他位假定为0，
则在
[N / 2]    01000
[N / 4]    00100
[N / 8]    00010
[N / 8]    00001
则所有相加等于01111 = 10000 - 1
由此推及其他位可得：(10101)!的质因数2的个数为10000 - 1 + 00100 - 1 + 00001 - 1 = 10101 - 3(二进制表示中1的个数)

推及一般N!的质因数2的个数为N-(N二进制表示中1的个数)

 

gcc编译器的内建函数，__builtin_popcount(x)

 

 

bitset的申明要指明长度

1
bitset<length> bi
这样就申明了一个长度为length的名叫bi的bitset

 赋值
bitset重载了[]运算符，故可以像bool数组那样赋值

bi[2] = 1;
这样就能将第二位赋值为1

常用函数
b1 = b2 & b3;//按位与
b1 = b2 | b3;//按位或
b1 = b2 ^ b3;//按位异或
b1 = ~b2;//按位补
b1 = b2 << 3;//移位
int one = b1.count();//统计1的个数
优化作用
常常碰到处理的数组只有0和1的变化，此时就可以使用bitset优化。比如求两个集合的交集可以使用按位与运算，求并集可以使用按位或运算

常用的成员函数：
b.any() b中是否存在置为1的二进制位？
b.none() b中不存在置为1的二进制位吗？
b.count() b中置为1的二进制位的个数
b.size() b中二进制位数的个数
b[pos] 访问b中在pos处二进制位
b.test(pos) b中在pos处的二进制位置为1么？
b.set() 把b中所有二进制位都置为1
b.set(pos) 把b中在pos处的二进制位置为1
b.reset( ) 把b中所有二进制位都置为0
b.reset( pos ) 把b中在pos处的二进制位置置为0
b.flip( ) 把b中所有二进制位逐位取反
b.flip( pos ) 把b中在pos处的二进制位取反
b.to_ulong( ) 把b中同样的二进制位返回一个unsigned，就是bieset的整数表示。

b.to_string返回字符串表示

 

十进制转二进制

#include<iostream>
#include<bitset>
using namespace std;
 
int main()
{
    bitset<100> b;
    int n;
    while(cin>>n)
    {
        b.reset();
        int index=0;
        do
        {
            b.set(index++,n%2);
            n=n/2;
        }
        while(n!=0);
        for(int i=index-1;i>-1;i--)
            cout<<b[i];
        cout<<endl;
    }
    return 0;
}

 

很难的一道bitset的题

http://codeforces.com/contest/781/problem/D

 http://www.voidcn.com/article/p-vvlnsrud-tz.html 题解。

 

拓扑排序+bitset

https://cn.vjudge.net/problem/HYSBZ-4484

 

题意：在一个DAG中，问最多删除多少边使得原图任意两点之间连通性不变。
题解：拓扑序+bitset
先求出原图的拓扑序，然后倒序处理。对于每个点，假如它的一条出边所连向的点已经可以通过另一个出点访问到，那么这条边就可以删去。所以我们把每个点的出点按拓扑序排序，然后用bitset维护连通性就好了。

#include<bits/stdc++.h>

using namespace std;
const int N = 3e4 + 5;
const int NN = 1e5 + 5;

vector<int> g[N];
bitset<N> b[N];
int deg[N];
int ans[N], ord[N], a[NN];

int comp(int x, int y) {
    return ord[x] < ord[y];
}

int main() {
    int n, m;
    scanf("%d%d", &n, &m);
    int u, v;
    for(int i = 0; i < m; i++) {
        scanf("%d%d", &u, &v);
        g[u].push_back(v);
        deg[v]++;
    }
    queue<int> q;
    int ind = 0;
    for(int i = 1; i <= n; i++) if(deg[i] == 0) q.push(i);
    while(!q.empty()) {
        int u = q.front();
        ord[u] = ++ind;
        ans[ind] = u;
        q.pop();
        int len = g[u].size();
        for(int i = 0; i < len; i++) {
            int v = g[u][i];
            if(--deg[v] == 0) q.push(v);
        }
    }
    int res = 0;
    for(int i = n; i; i--) {
        int u = ans[i];
        int len = g[u].size();
        b[u][u] = 1;
        for(int j = 0; j < len; j++) a[j] = g[u][j];
        sort(a, a + len, comp);
        for(int j = 0; j < len; j++) {
            int v = a[j];
            if(b[u][v]) res++;
            else b[u] |= b[v];
        }
    }
    printf("%d\n", res);
    return 0;
}

 

 

 

bitset优化dp

 

https://cn.vjudge.net/problem/HDU-5745

https://blog.csdn.net/MikeZHW/article/details/52026030  原博客

[题意]
给定模式串和主串，模式串可以交换相邻位子的字符，且可以交换多个位子，但每个字符只能被交换一次。问模式串能否通过该变换与主串匹配？输出主串中每个位子的匹配结果，1为可匹配，0为不可匹配。

[分析]
赛上被这道题坑哭了，看到那么多队过自己却没有思路，好不容易想到个方法把样例过了却T了。最后走投无路写了个暴力就A了，1500ms，吓死。
不过赛后貌似加强了数据，卡了暴力，丧病。
不过趁机学习了下bitset优化的方法，还不错

dp公式很容易得到
设主串为s，模式串为t，dp[i][j][k]表示主串到i，模式串到j，模式串当前位置的状态为k（0：不动，1：与前面交换，2：与后面交换）是否匹配，则：
dp[i][j][0] = （dp[i-1][j-1][0] || dp[i-1][j-1][1] ） && （s[i] == t[j]）
dp[i][j][1] = （dp[i-1][j-1][2] ) && ( s[i-1] == t[j] )
dp[i][j][2] = （dp[i-1][j-1][0] || dp[i-1][j-1][1] ）&& （s[i+1] == t[j] )

优化1：
第二维j实际上只与j-1有关，可以滚动
优化2：
所有值都是bool类型，可以用bitset压位，通过bitset之间的位运算，常数优化

其实听了这些对不会玩bitset的来说还是一脸懵逼（比如我
所以具体一点吧

bitset<N> dp[2][3] , ch[26] ;

首先需要这些bitset，前者当然是存dp值，2用于滚动，3存三种状态；后者对应26个字母是否在主串中的某个位子出现，比如ch[0][5]表示字母a是否出现在主串中的第5个位子

dp[cur][1] = (dp[cur^1][2] << 1) & ch[t[i-1]-'a'] ;
转移的时候这样搞，这里只列出了k=1的转移写法
由于两个bitset可以直接进行位运算，相当于一次运算直接把1-n的所有dp值全部算出，复杂度却只有O(n/w)（w是机器的字节长）
所以预处理每个字符是否在每个位子出现，保存在bitset中，就是为了这里的操作
还有一个疑问，为何要<<1?
很简单，因为i由i-1推得，所以左移1使得对应的位对齐，再运算
这样写刚好卡过

#include <bits/stdc++.h>
using namespace std ;
const int N = 100000 + 5 ;
typedef long long LL ;

int T , n , m ;
char s[N] , t[N] ;
bitset<N> dp[2][3] , ch[26] ;

int main()
{
    scanf( "%d" , &T ) ;
    while( T-- )
    {
        scanf( "%d%d" , &n , &m ) ;
        scanf( "%s%s" , s+1 , t+1 ) ;
        for( int i = 0 ; i < 26 ; i++ )
            ch[i].reset() ;
        for( int i = 1 ; i <= n ; i++ )
            ch[s[i]-'a'].set(i) ;
        int cur = 0 ;
        dp[cur][0].set() ;
        dp[cur][1].reset() ;
        dp[cur][2].reset() ;
        for( int i = 1 ; i <= m ; i++ )
        {
            cur ^= 1 ;
            for( int j = 0 ; j < 3 ; j++ )
                dp[cur][j].reset() ;
            dp[cur][0] = ((dp[cur^1][0] | dp[cur^1][1]) << 1) & ch[t[i]-'a'] ;
            if( i > 1 )
                dp[cur][1] = (dp[cur^1][2] << 1) & ch[t[i-1]-'a'] ;
            if( i < m )
                dp[cur][2] = ((dp[cur^1][1] | dp[cur^1][0]) << 1) & ch[t[i+1]-'a'] ;
        }
        for( int i = m ; i <= n ; i++ )
            s[i-m] = '0' + (dp[cur][0][i] | dp[cur][1][i]) ;
        for( int i = n-m+1 ; i < n ; i++ )
            s[i] = '0' ;
        s[n] = 0 ;
        puts(s) ;
    }
    return 0 ;
}