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 = 505;

struct twosat
{
    int n;
    vector<int> g[maxn*2];
    bool mark[maxn*2];
    int s[maxn*2],c;
    int ty[maxn];
    
    bool dfs(int x)
    {
        if (mark[x^1]) return false;
        if (mark[x]) return true;
        
        mark[x] = true;
        
        s[c++] = x;
        
        for (int i = 0;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 * 2 + xval;
        y = y * 2 + yval;
        
        g[x^1].push_back(y);
    }
    
    void init(int n)
    {
        this -> n = n;
        memset(mark,0,sizeof(mark));
        memset(ty,0,sizeof(ty));
        for (int i = 0;i <= n * 2;i++) g[i].clear(); 
    }
    
    bool solve()
    {
        for (int i = 0;i < n * 2;i += 2)
        {
            if (!mark[i] && !mark[i+1])
            {
                c = 0;
                
                if (!dfs(i))
                {
                    while (c > 0) mark[s[--c]] = 0;
                    if (!dfs(i+1)) return false;
                    else
                    {
                        while (c > 0) mark[s[--c]] = 0;
                        ty[i/2] = 2;
                    } 
                }
                else
                {
                    while (c > 0) mark[s[--c]] = 0;
                    if (!dfs(i+1))
                    {
                        ty[i/2] = 1;
                        while (c > 0) mark[s[--c]] = 0;
                    }
                    else
                    {
                        ty[i/2] = 3;
                        while (c > 0) mark[s[--c]] = 0;
                    }
                }
            }
            else
            {
                if (mark[i]) ty[i/2] = 1;
                else ty[i/2] = 2;
            }
        }
        
        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 = 0;
    
    while (scanf("%d%d",&n,&m) != EOF)
    {
        if (n == 0 && m == 0) break;
        
        twosat.init(n);
        
        for (int i = 0;i < m;i++)
        {
            int k;
            scanf("%d",&k);
            
            int a[4];
            char ch[4][2];
            
            for (int j = 0;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 <= 2)
            {
                for (int j = 0;j < k;j++)
                {
                    if (ch[j][0] == 'y') twosat.add_clause(a[j],1,a[j],1);
                    else twosat.add_clause(a[j],0,a[j],0);
                }
            }
            else
            {
                bool b[4];
                
                for (int j = 0;j < k;j++)
                {
                    b[j] = ch[j][0] == 'y' ? 1 : 0;
                }
                
                for (int j = 0;j < k;j++)
                {
                    for (int l = 0;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 = 0;i < n;i++)
            {
                switch(twosat.ty[i])
                {
                    case 1 : printf("n");break;
                    case 2 : printf("y");break;
                    case 3 : printf("?");break;
                }
            }
            printf("
");
        }
        else printf("Case %d: impossible
",++kase);
    }
    
    return 0;
}