位运算的一种应用 和 hiho1516过河解题报告

初始i=s

每次：i=(i-1) & s

直到i=0

etc.
11000
10000
01000
00000

10000=10001 & 11000
01000=01111 & 11000
00000=00111 & 11000

etc.
11110
11100
11010
11000
10110
10100
10010
10000
01110
01100
01010
01000
00110
00100
00010
00000

证明：
所有i满足 (s & i)==i，
且所有满足 (s & i)==i 的数都出现过

1.
证明：(s & i)==i
因为“i=(i’-1) & s”，

对于i的第t位i(t)：

当s(t)=0时，i(t)=_ & 0 = 0
_ & 0 = 0

当s(t)=1时
1 & i(t) = i(t)

所以(s & i)==i成立

2.
证明：
所有满足 (s & i)==i 的数都出现过

对于s中值为0的位 s(t)，因为“i=(i’-1) & s”，所以i(t)永远为0

对于s中值位0的位 s(t)，因为“i=(i’-1) & s”，所以i(t)永远不会因为s而影响，所以i(t)的值 为(i’-1)的第t位

即“(s & i)==i”相当于原来s中的‘1’组成的数字从11…1到00…0每次减少1的变化，而原来s中的‘0’永远不变

得证

Usage：
共有n个人，当前有m个人可以工作，每个人可以被选或不被选，求出这m个人的所有选择情况(用二进制表示)

Problem：
hiho1516

bfs+状态压缩：

重要的是弄清每次生成新的状态的方法。。。

 #include <stdio.h>
 #include <stdlib.h>
 #include <stdbool.h>

 struct node
 {
     long pos,step,sum;
 }q[];
 //2^16 * 2(两岸)

 long n,cond[],g[],num[][];//0为起始岸；1为终止岸；2为船 总数(二进制)
 long vis1[],vis2[],vis3;
 bool vis[][];

 bool judge()
 {
     long i,j,k;
     for (j=;j<;j++)
     {
         for (i=;i<g[cond[j]];i++)
         {
             k=num[cond[j]][i];
             if (((vis1[k] & cond[j])!=) && ((vis2[k] & cond[j])==))
                 return false;
         }

 //        for (i=0;i<n;i++)
 //            if (((cond[j]>>i) & i)!=1)
 //                if ( ((vis1[i] & cond[j])!=0)  && ((vis2[i] & cond[j])==0) )
 //                    return false;
     }
     if ((cond[] & vis3)==)
         return false;
     return true;
 }

 int main()
 {
     long m,a,b,c,x,y,head,tail,i,j,k,total,pos,pos_,sum,step,mul[];
     scanf("%ld%ld",&n,&m);
     mul[]=;
     for (i=;i<=n;i++)
         mul[i]=mul[i-]<<;
     total=(<<n)-;
     for (i=;i<=total;i++)
     {
         g[i]=;
         j=i;
         k=;
         while (j>)
         {
             if ((j & )==)
             {
                 num[i][g[i]]=k;
                 g[i]++;
             }
             k++;
             j=j>>;
         }
     }

     scanf("%ld%ld%ld",&a,&b,&c);
     for (i=;i<n;i++)
     {
         vis1[i]=;
         vis2[i]=;
     }
     vis3=;
     for (i=;i<=a;i++)
     {
         scanf("%ld%ld",&x,&y);
         vis1[x]+=<<y;
     }
     for (i=;i<=b;i++)
     {
         scanf("%ld%ld",&x,&y);
         vis2[y]+=<<x;
     }
     for (i=;i<=c;i++)
     {
         scanf("%ld",&x);
         vis3+=<<x;
     }
     for (i=;i<;i++)
         for (j=;j<;j++)
             vis[i][j]=true;

     head=;
     tail=;
     q[].pos=;
     q[].step=;
     q[].sum=total;
     vis[total][]=false;

     while (head<tail)
     {
         head++;

         //另外的优化：
         //如果在左边，则送尽量多的人到右边
         //如果在右边，则送尽量少的人到左边

         //编写程序的简单性：两岸做法的对称性 (Same)，从而合二为一

         pos=q[head].pos;
         pos_=pos ^ ;
         sum=q[head].sum;
         step=q[head].step+;
         //不必取0，前后必会发生变化
         for (i=sum;i>;i=(i-) & sum)
             if (g[i]<=m)
              {
                  cond[]=i;
                  cond[pos]=sum-i;
                  cond[pos_]=total-cond[pos];

                  if (vis[cond[pos_]][pos_]==true && judge()==true)
                  {
 //                     printf("%ld %ld\n",cond[pos_],pos_);
                      if (pos_== && cond[]==total)
                      {
                          printf("%ld\n",step);
                          return ;
                     }
                     tail++;
                     q[tail].pos=pos_;
                     q[tail].step=step;
                     q[tail].sum=cond[pos_];
                     vis[cond[pos_]][pos_]=false;
                 }
             }
     }
     printf("-1\n");
     return ;
 }

/*

位运算的优势：
1.相比正常运算极快的运行速度
2.存储的减少
3.程序编写的简单(和不容易出错)

*/