uvalive 4452 The Ministers’ Major Mess

题意：

有一些部长需要对某些账单进行投票。

一个部长最多对4个账单进行投票，且每票对一个账单通过，要么否决。

问是否存在一个方案使得所有部长有超过半数的投票被通过，如果有，那么说明哪些账单的决定是明确的，哪些是不明确的；否则说明不可能。

思路：

2-SAT。

一开始觉得这是一个k-SAT问题，但是因为有着所有部长的投票有超过半数被通过这个条件存在，所以可以简化。

对于一票或者两票的部长，那么所有条件都要被满足，意味着某些账单的决定是确定。

如何表示一个条件是确定的呢，这是从这个题中学习到的一点，不是简单的标记这个条件的真假，而是从自己向自己的对立面连边，如果在搜索的过程中，发现自己和自己的对立面均被标记，那么就产生矛盾从而不满足条件了。

然后是对于3票或者4票的部长，要超过一半，如果一旦一个账单取相反的决定，那么其它账单都要取与输入相同的决定才能保证查过一半，再根据这个条件连边。

之后再解决如何确定一个账单的决定是否明确，对于一个账单，如果标记为通过能找到方案，否决也能找到方案，那么这个账单的决定就是不明确的，否则就可以判断其是明确的。在每一次标记了一个条件进行搜索之后，都必须将这个过程中标记过的点全部初始化，才能保证下一次搜索的正确。

代码：

 #include <stdio.h>
 #include <string.h>
 #include <string>
 #include <iostream>
 #include <vector>
 #include <algorithm>
 using namespace std;

 const int maxn = ;

 struct twosat
 {
     int n;
     vector<int> g[maxn*];
     bool mark[maxn*];
     int s[maxn*],c;
     int ty[maxn];

     bool dfs(int x)
     {
         if (mark[x^]) return false;
         if (mark[x]) return true;

         mark[x] = true;

         s[c++] = x;

         for (int i = ;i < g[x].size();i++)
         {
             if (!dfs(g[x][i])) return false;
         }

         return true;
     }

     void add_clause(int x,int xval,int y,int yval)
     {
         x = x *  + xval;
         y = y *  + yval;

         g[x^].push_back(y);
     }

     void init(int n)
     {
         this -> n = n;
         memset(mark,,sizeof(mark));
         memset(ty,,sizeof(ty));
         for (int i = ;i <= n * ;i++) g[i].clear();
     }

     bool solve()
     {
         for (int i = ;i < n * ;i += )
         {
             if (!mark[i] && !mark[i+])
             {
                 c = ;

                 if (!dfs(i))
                 {
                     while (c > ) mark[s[--c]] = ;
                     if (!dfs(i+)) return false;
                     else
                     {
                         while (c > ) mark[s[--c]] = ;
                         ty[i/] = ;
                     }
                 }
                 else
                 {
                     while (c > ) mark[s[--c]] = ;
                     if (!dfs(i+))
                     {
                         ty[i/] = ;
                         while (c > ) mark[s[--c]] = ;
                     }
                     else
                     {
                         ty[i/] = ;
                         while (c > ) mark[s[--c]] = ;
                     }
                 }
             }
             else
             {
                 if (mark[i]) ty[i/] = ;
                 else ty[i/] = ;
             }
         }

         return true;
     }

     /*void judge()
     {
         for (int i = 0;i < n * 2;i += 2)
         {
             if (!mark[i] && !mark[i+1])
             {
                 c = 0;

                 bool tr = 0;
                 bool fa = 0;

                 if (dfs(i))
                 {
                     fa = 1;
                     while (c > 0) mark[s[--c]] = 0;
                 }

                 if (dfs(i+1))
                 {
                     tr = 1;
                     while (c > 0) mark[s[--c]] = 0;
                 }

                 if (tr && fa) ty[i/2] = 3;
                 else if (tr) ty[i/2] = 2;
                 else ty[i/2] = 1;
             }
             else
             {
                 //if (i == 0) printf("2333");
                 if (mark[i]) ty[i/2] = 1;
                 else ty[i/2] = 2;
             }
         }
     }*/
 }twosat;

 int main()
 {
     int n,m;
     int kase = ;

     while (scanf("%d%d",&n,&m) != EOF)
     {
         if (n ==  && m == ) break;

         twosat.init(n);

         for (int i = ;i < m;i++)
         {
             int k;
             scanf("%d",&k);

             int a[];
             char ch[][];

             for (int j = ;j < k;j++)
             {
                 scanf("%d%s",&a[j],ch[j]);
                 a[j]--;
             }

             //for (int j = 0;j < k;j++) vis[a[j]] = 1;

             if (k <= )
             {
                 for (int j = ;j < k;j++)
                 {
                     if (ch[j][] == 'y') twosat.add_clause(a[j],,a[j],);
                     else twosat.add_clause(a[j],,a[j],);
                 }
             }
             else
             {
                 bool b[];

                 for (int j = ;j < k;j++)
                 {
                     b[j] = ch[j][] == 'y' ?  : ;
                 }

                 for (int j = ;j < k;j++)
                 {
                     for (int l = ;l < k;l++)
                     {
                         if (j != l)
                         {
                             twosat.add_clause(a[j],b[j],a[l],b[l]);
                         }
                     }
                 }
             }
         }

         if (twosat.solve())
         {
             //twosat.judge();

             printf("Case %d: ",++kase);

             for (int i = ;i < n;i++)
             {
                 switch(twosat.ty[i])
                 {
                     case  : printf("n");break;
                     case  : printf("y");break;
                     case  : printf("?");break;
                 }
             }
             printf("\n");
         }
         else printf("Case %d: impossible\n",++kase);
     }

     return ;
 }