hdu 4421 Bit Magic

【题意】

这个函数是给A求B的，现在给你B，问你是否能有A的解存在。

【2-SAT解法】

对于每个A[i]的每一位运行2-sat算法，只要跑到强连通就可以结束，应为只要判断是否有解，后面拓扑求解就不需要了。构图和算法思想和基本的2-sat一致，详见我的2-sat博文。

 #include <stdio.h>
 #include <string.h>
 inline int min(int a,int b){return a>b?b:a;}
 struct edge
 {
     int v,next;
     edge(int d=,int n=-):v(d),next(n){}
     void set(int d,int n){v=d;next=n;}
 }data[*];
 int head[],hn;
 void adde(int a,int b)
 {
     data[hn].set(b,head[a]);
     head[a]=hn++;
 }
 int n;
 int b[][];
 int dfn[],low[],sta[],belong[];
 bool ifin[];
 int top,group,dep;
 void tarjan(int u)
 {
     dfn[u]=low[u]=++dep;
     sta[++top]=u;
     ifin[u]=true;
     for (int i=head[u];i!=-;i=data[i].next)
     {
         int v=data[i].v;
         if (!dfn[v])
         {
             tarjan(v);
             low[u]=min(low[u],low[v]);
         } else
         {
             if (ifin[v]) low[u]=min(low[u],dfn[v]);
         }
     }
     if (dfn[u]==low[u])
     {
         int j;
         ++group;
         do
         {
             j=sta[top--];
             belong[j]=group;
             ifin[j]=false;
         } while (u!=j);
     }
 }
 void init()
 {
     hn=dep=group=;
     top=-;
     memset(head,-,sizeof head);
     memset(dfn,,sizeof dfn);
     memset(ifin,false,sizeof ifin);
 }
 bool judge()
 {
     for (int i=;i<n;++i)
         if (belong[i]==belong[i+n]) return false;
     return true;
 }
 bool solve()
 {
     for (int i=;i<n;++i)
         for (int j=i;j<n;++j)
     {
         if (i==j && b[i][j]) return false;
         if (b[i][j]!=b[j][i]) return false;
     }
     for (int k=;k<;++k)
     {
         init();
         for (int i=;i<n;++i)
             for (int j=i;j<n;++j)
         {
             int m=b[i][j]&(<<k);
             if (i==j) continue;
             if (i& && j&) // |
             {
                 if (m)
                 {
                     adde(i,j+n);
                     adde(j,i+n);
                 } else
                 {
                     adde(i+n,i);
                     adde(j+n,j);
                 }
             } else if (!(i&) && !(j&)) //&
             {
                 if (m)
                 {
                     adde(i,i+n);
                     adde(j,j+n);
                 } else
                 {
                     adde(i+n,j);
                     adde(j+n,i);
                 }
             } else   // ^
             {
                 if (m)
                 {
                     adde(i,j+n);
                     adde(j,i+n);
                     adde(j+n,i);
                     adde(i+n,j);
                 } else  //==
                 {
                     adde(i,j);
                     adde(j,i);
                     adde(i+n,j+n);
                     adde(j+n,i+n);
                 }
             }
         }
         for (int i=;i<(n<<);++i)
             if (!dfn[i]) tarjan(i);
         if (!judge()) return false;
     }
     return true;
 }
 int main()
 {
     while (~scanf("%d",&n))
     {
         for (int i=;i<n;++i)
             for (int j=;j<n;++j)
               scanf("%d",&b[i][j]);
         if (solve()) puts("YES"); else puts("NO");
     }
 }

2-sat

【并查集】

主要思想是以A中每个元素的每一位作为一个基本单位，根据b中的值来确定每一位之间的等价关系，值相等的并在一个集合，每当能确定一个新的关系时验证原先的关系是否矛盾。不过在处理的时候有点小技巧，与2-sat的思想类似，扩充成2N个点，对于每一位，有个点代表其值，另一点代表其值的反。能确定一位的值时要同时更新这2点，从一方面说是充分发掘信息，另一方面说是为了异或运算的判断服务，因为异或不能确定一个值，但能确定相对关系，需要用到反。

并查集的算法在这题里比2-SAT的快，剩了些不必要的计算，思想也挺巧妙的。

 #include <stdio.h>
 #include <string.h>
 #define N  501*32
 #define m1 mset.find(1)
 #define m0 mset.find(0)
 struct myset
 {
     int uset[*+];
     myset(){init();};
     void init(){memset(uset,-,sizeof uset);}
     int find(int k)
     {
         if (uset[k]==-) return k;
         return uset[k]=find(uset[k]);
     }
     void uion(int a,int b)
     {
         int aa=find(a);
         int bb=find(b);
         if (aa==bb) return;
         uset[aa]=bb;
     }
 }mset;
 int b[][],n;
 bool solve()
 {
     for (int i=;i<n;++i)
         for (int j=i;j<n;++j)
     {
         if (i==j && b[i][j]) return false;
         if (b[i][j]!=b[j][i]) return false;
     }
     for (int i=;i<n;++i)
         for (int j=;j<n;++j)
     {
         if (i==j) continue;
         if (i& && j&)
         {
             for (int k=;k<;++k)
             {
                 if (b[i][j]&(<<k) == )
                 {
                     int p1=i*+k+;
                     int p2=j*+k+;
                     if (mset.find(p1)==m1 || mset.find(p2)==m1 || mset.find(p1)==mset.find(p2+N)) return false;
                     mset.uion(p1,);
                     mset.uion(p2,);
                     mset.uion(p1+N,);
                     mset.uion(p2+N,);
                 }
             }
         } else
         if (!(i&) && !(j&))
         {
             for (int k=;k<;++k)
             {
                  if (b[i][j]&(<<k))
                 {
                     int p1=i*+k+;
                     int p2=j*+k+;
                     if (mset.find(p1)==m0 || mset.find(p2)==m0 || mset.find(p1)==mset.find(p2+N)) return false;
                     mset.uion(p1,);
                     mset.uion(p2,);
                     mset.uion(p1+N,);
                     mset.uion(p2+N,);
                 }
             }
         } else
         {
              for (int k=;k<;++k)
             {
                   int p1=i*+k+;
                   int p2=j*+k+;
                  if (b[i][j]&(<<k))
                 {
                     if (mset.find(p1)==mset.find(p2)) return false;
                     mset.uion(p1,p2+N);
                     mset.uion(p2,p1+N);
                 } else
                 {
                     if (mset.find(p1)==mset.find(p2+N) ) return false;
                     mset.uion(p1,p2);
                     mset.uion(p1+N,p2+N);
                 }
             }
         }
     }
     return true;
 }
 int main()
 {
     while (~scanf("%d",&n))
     {
         mset.init();
         for (int i=;i<n;++i)
             for (int j=;j<n;++j)
             scanf("%d",&b[i][j]);
         if (solve()) puts("YES"); else puts("NO");
     }
 }

并查集