Bitset重识

Posted ---学习ing---

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Bitset重识相关的知识,希望对你有一定的参考价值。

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

一题题目:

一题题解:

 

  • 这个题目哪来入门再好不过了,支老板之前没有接触过这个东西,然后一点即通:就是把一个int(32位)拆成32个只放0或1的位置,然后这32个的单点操作或者32个一起操作的复杂度是O(1),所以长度位N的bitset的一次单点操作是O(1),整体操作是O(N/w),其中w=32。(long long 是64)。
  • 然后Bitset还有强大是&和|功能,以及count(1)等功能。
  • 但是Bitset最厉害的地方在于优化图论的dfs部分: 我们知道,dfs的时候对于当前点X,会继续访问和X有关联的所有点,continue忽略vis过的点。而有了bitset,我们可以直接得到有关联的,而且没有vis过的点,这样可以保证不去访问不必要的边,这在稠密图里改进极大。

 

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

二题题目:

二题题解:

  • 跳过缩点建图。
  • 第一部分是求Bitset,得到每个点可以访问到的点。 
  • 第二部分求对应的权值和,巧妙的利用了分块来优化,复杂度/13。而且这个13的选择也是经过计算的,2^13<n,保证分块计算的复杂度影响小于前面的复杂度,新技能,学到了。

 

POJ3275:Ranking the Cows

 

题意:有N头奶牛,现在给出M对产奶量关系U>V,问至少还需要知道多少奶牛可以做到全部奶牛产奶关系。

思路:有向图,问至少再加多少边,使得任意两点S、T的可以到达(S到达T或者到达S)。闭包传递后不能到达的需要加边,ans++。

 至于为什么ans++,可以参考,http://www.cnblogs.com/hua-dong/p/8538980.html

 

Floyd稍微优化:    注意边少,可以加一维限制,勉强通过。

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=1010;
int mp[maxn][maxn];
int main()
{
    int N,M,ans,i,j,k;
    while(~scanf("%d%d",&N,&M)){
        ans=0;
        memset(mp,0,sizeof(mp));
        for(i=1;i<=M;i++){
            scanf("%d%d",&j,&k);
            mp[j][k]=1;
        }
        for(k=1;k<=N;k++)
         for(i=1;i<=N;i++)
          if(mp[i][k])
           for(j=1;j<=N;j++)
            if(mp[k][j]) mp[i][j]=1;
        for(i=1;i<=N;i++)
         for(j=i+1;j<=N;j++)
          if(!mp[i][j]&&!mp[j][i])
           ans++;
        printf("%d\\n",ans);
    }
    return 0;
}
View Code

Bitset优化Floyd: 复杂度降为O(N^3/32)<3*10^7。 

#include<cstdio>
#include<bitset>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=1010;
bitset<maxn>mp[maxn];
int main()
{
    int N,M,ans,i,j,k;
    while(~scanf("%d%d",&N,&M)){
        ans=0;memset(mp,0,sizeof(mp));
        for(i=1;i<=M;i++){
            scanf("%d%d",&j,&k);
            mp[j].set(k);
        }
        
        for(k=1;k<=N;k++)
         for(i=1;i<=N;i++)
          if(mp[i][k])
           mp[i]|=mp[k];
        for(i=1;i<=N;i++)
         for(j=i+1;j<=N;j++)
          if(!mp[i][j]&&!mp[j][i])
           ans++;
        printf("%d\\n",ans);
    }
    return 0;
}
 
View Code

 

POJ2443:Set Operation

题意:给定N个集合,Q次询问,对每次询问,求X,Y是否在同一集合出现过,注意X=Y时,X在一个集合里至少出现一次就满足了。

思路:用Bitset来表示每个元素在哪些集合出现过,如果X和Y出现的集合有交集,则满足。

#include<cstdio>
#include<bitset>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=10000;
bitset<1010>s[maxn+10];
int read()
{
    char c=getchar(); int res;
    while(c>\'9\'||c<\'0\') c=getchar();
    for(res=0;c>=\'0\'&&c<=\'9\';c=getchar()) res=(res<<3)+(res<<1)+c-\'0\';
    return res;
}
int main()
{
    int N,Q,i,num,x,y;
    while(~scanf("%d",&N)){
        for(i=1;i<=maxn;i++) s[i].reset();
        for(i=1;i<=N;i++){
            num=read();
            while(num--){
                x=read();
                s[x][i]=1; //s[x].set(i);
            }
        }
        Q=read();
        while(Q--){
            x=read(); y=read();
            if((s[x]&s[y]).count()) puts("Yes"); //.any()
            else puts("No");
        }
    }
    return 0;
}
View Code

 

AtCoder - 3857:Median Sum

题意:给定N个数,有2^N-1种非空组合,求这些组合的和排序后的中位数。

思路:由对称性,知道中位数略大于Sum/2,所以我们从(Sum+1)/2后面所有的可能中,选择最近的一个。(证明见下面。)

具体实现:需要得到背包结果有哪些可能性,这个只需要Bitset加速一下即可得到。

证明:见前辈写的,很清晰,只要利用对称性即可。http://blog.csdn.net/zzzzone/article/details/79115522

#include<bitset>
#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=2002;
bitset<maxn*maxn+10>s;
int main()
{
    int N,x,ans;
    while(~scanf("%d",&N)){
        s.reset(); ans=0;
        s[0]=1;
        for(int i=1;i<=N;i++){
            scanf("%d",&x);
            s|=(s<<x);
            ans+=x;
        }
        for(int i=(ans+1)/2;;i++){
            if(s[i]){
               printf("%d\\n",i);
               break;
            }
        }
    }
    return 0;
}
View Code

 

CodeForce 914F:Substrings in a String

题意:

           给定一个小写字符组成的字符串S;现在有Q种操作,对于每个操作Q,输入opt,如果opt==1,输入x,c,表示把S[x]改为c,(c是小写字母)。 如果opt==2,输入字符串T,输出S种有多少个字串==T(字串可以重叠),

思路:

          1,假设我们要统计S里有多少个T,先统计S里面字符==T[0]的是哪些,然后统计S中有T[0]的位置后面跟的字符==T[1]的有哪些,然后统计S中有T[0]的位置后面跟的字符==T[1]的而且后面跟的字符==T[2]的有哪些.....直到对比到S[len-1]。    

          2,最后利用位移可以得到某个区间的1的个数。

#include<bitset>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=100010;
bitset<maxn>s[27],ans;
char a[maxn],b[maxn],c[3];
void read(int &res)
{
    char c=getchar();
    while(c>\'9\'||c<\'0\') c=getchar();
    for(res=0;c>=\'0\'&&c<=\'9\';c=getchar()) res=(res<<3)+(res<<1)+c-\'0\';
}
int main()
{
    scanf("%s",a+1);
    int T=strlen(a+1);
    int i,j,l,r,Q,opt;
    for(i=1;i<=T;i++)
        s[a[i]-\'a\'].set(i);
    read(Q);
    while(Q--){
        read(opt);
        if(opt==1){
            scanf("%d%s",&j,c);
            s[a[j]-\'a\'][j]=0;
            s[(a[j]=c[0])-\'a\'][j]=1;
        }
        else {
            read(l); read(r);
            scanf("%s",b);
            int S=strlen(b);
            if(S>r-l+1) {
                 puts("0"); continue;
            }
            ans.set();
            for(i=0;i<S;i++){
                ans&=(s[b[i]-\'a\']>>i);
            }
            printf("%d\\n",(ans>>l).count()-(ans>>(r-S+2)).count());
        }
    }
    return 0;
}
View Code

 

CodeForces-707D:Persistent Bookcase

题意:现在有一个N*M的书架,有Q个操作,对于每个操作,输入opt:

          如果opt==1,那么输入x,y,如果第x行第y列无书,则放一本书。

          如果opt==2,那么输入x,y,如果第x行第y列有书,则取走那本书。

          如果opt==3,那么输入x,将第x行有书的取走,无书的位置放一本。

          如果opt==4,那么输入k,表示把书架的情况恢复为第k次操作后的样貌,k在当前操作之前。

思路:初看可能是可持久化数据结构,但是注意到整体操作顺序为有根树,可以DFS回溯,对于书架上的情况,可以直接积累或者Bitset假设。

#include<bitset>
#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=1010;
const int maxm=100010;
bitset<maxn>s[maxn],P;
int N,M,Q;
int Laxt[maxm],Next[maxm],To[maxm],cnt;
int opt[maxm],x[maxm],y[maxm],ans[maxm];
void read(int &res)
{
    char c=getchar(); res=0;
    for(;c>\'9\'||c<\'0\';c=getchar());
    for(;c<=\'9\'&&c>=\'0\';c=getchar()) res=(res<<3)+(res<<1)+c-\'0\';
}
void add(int u,int v)
{
    Next[++cnt]=Laxt[u];
    Laxt[u]=cnt;
    To[cnt]=v;
}
void dfs(int u,int Now)
{
    for(int i=Laxt[u];i;i=Next[i]){
        int v=To[i];
        if(opt[v]==1&&s[x[v]][y[v]]==0) {
                s[x[v]][y[v]]=1;
                ans[v]=Now+1;
                dfs(v,ans[v]);
                s[x[v]][y[v]]=0;
        }
        else if(opt[v]==2&&s[x[v]][y[v]]==1) {
                s[x[v]][y[v]]=0;
                ans[v]=Now-1;
                dfs(v,ans[v]);
                s[x[v]][y[v]]=1;
        }
        else if(opt[v]==3){
                ans[v]=Now-s[x[v]].count();  
                s[x[v]]^=P;  
                ans[v]+=s[x[v]].count(); 
                dfs(v,ans[v]);
                s[x[v]]^=P;
        }
        else {
                ans[v]=Now;
                dfs(v,ans[v]);
        }
     }
}
int main()
{
    read(N); read(M); read(Q);
    for(int i=1;i<=M;i++) P.set(i);
    for(int i=1;i<=Q;i++){
        scanf("%d",&opt[i]);
        if(opt[i]==1||opt[i]==2) read(x[i]),read(y[i]);
        else read(x[i]);
        if(opt[i]==4) add(x[i],i);
        else add(i-1,i);
    }
    dfs(0,0);
    for(int i=1;i<=Q;i++) printf("%d\\n",ans[i]);
    return 0;
}
View Code

 

还有两个很重要的函数,去遍历哪些为1的地方,bitset._Find_first(),和bitset._Find_next(i)

以上是关于Bitset重识的主要内容,如果未能解决你的问题,请参考以下文章

重识Nginx - 系列导读

Object重识

重识Activity——生命周期详解

重识信息收集

重识信息收集

重识maven