POJ3295 Tautology(栈+枚举)

Description

WFF 'N PROOF is a logic game played with dice. Each die has six faces representing some subset of the possible symbols K, A, N, C, E, p, q, r, s, t. A Well-formed formula (WFF) is any string of these symbols obeying the following rules:

• p, q, r, s, and t are WFFs
• if w is a WFF, Nw is a WFF
• if w and x are WFFs, Kwx, Awx, Cwx, and Ewx are WFFs.

The meaning of a WFF is defined as follows:

• p, q, r, s, and t are logical variables that may take on the value 0 (false) or 1 (true).
• K, A, N, C, E mean and, or, not, implies, and equals as defined in the truth table below.

Definitions of K, A, N, C, and E

w  x	Kwx	Awx	Nw	Cwx	Ewx
1  1	1	1	0	1	1
1  0	0	1	0	0	0
0  1	0	1	1	1	0
0  0	0	0	1	1	1

 

A tautology is a WFF that has value 1 (true) regardless of the values of its variables. For example, ApNp is a tautology because it is true regardless of the value of p. On the other hand, ApNq is not, because it has the value 0 for p=0, q=1.

You must determine whether or not a WFF is a tautology.

Input

Input consists of several test cases. Each test case is a single line containing a WFF with no more than 100 symbols. A line containing 0 follows the last case.

Output

For each test case, output a line containing tautology or not as appropriate.

Sample Input

ApNp
ApNq
0

Sample Output

tautology
not

Source

 题意：给你一个表达式，表达式中有p，q，r，s，t五个变量，以及K,A,N,C,E五个函数

求该表达式是否为永真式，即pqrst无论如何变化达标的的值始终是真的？

 题解：既然有表达式嘛，那么肯定是要栈来做表达式求值，这题无非多了几个运算符和几次枚举而已，然而因为看错题意WA了好几次，唉……

代码如下：

#include<map>
#include<stack>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define fa puts("fuck");
using namespace std;

char d[];
int vis[]= {,};

int K(int a,int b)
{
    return a&b;
}

int A(int a,int b)
{
    return a|b;
}

int N(int a)
{
    return !a;
}

int C(int a,int b)
{
    return (!a)|b;
}

int E(int a,int b)
{
    return a==b;
}

map<char,int> m;

int dfs(int p,int q,int r,int s,int t)
{
    int cnt;
    stack<int> stack1;
    for(int i=strlen(d)-; i>=; i--)
    {
        if(d[i]=='K'||d[i]=='A'||d[i]=='C'||d[i]=='E')
        {
            int tmp1=stack1.top();
            stack1.pop();
            int tmp2=stack1.top();
            stack1.pop();
            switch (d[i])
            {
                case 'K':
                    stack1.push(K(tmp1,tmp2));
                    break;
                case 'A':
                    stack1.push(A(tmp1,tmp2));
                    break;
                case 'C':
                    stack1.push(C(tmp1,tmp2));
                    break;
                case 'E':
                    stack1.push(E(tmp1,tmp2));
            }
        }
        else
        {
            if(d[i]=='N')
            {
                int tmp1=stack1.top();
                stack1.pop();
                stack1.push(!tmp1);
            }
            else
            {
                stack1.push(m[d[i]]);
            }
        }
    }
    int ans=stack1.top();
    while(!stack1.empty())
    {
        stack1.pop();
    }
    return ans;
}

int main()
{
    while(scanf("%s",d),d[]!='')
    {
        memset(vis,,sizeof(vis));
        for(int p=; p<=; p++)
        {
            m['p']=p;
            for(int q=; q<=; q++)
            {
                m['q']=q;
                for(int r=; r<=; r++)
                {
                    m['r']=r;
                    for(int s=; s<=; s++)
                    {
                        m['s']=s;
                        for(int t=; t<=; t++)
                        {
                            m['t']=t;
                            vis[dfs(p,q,r,s,t)]=;
                        }
                    }
                }
            }
        }
        if(vis[])
        {
            puts("not");
        }
        else
        {
            puts("tautology");
        }
    }

}

//k(a,b)=a&b
//a(a,b)=a|b
//e(a)=!a
//c(a,b)=(!a)|b
//e(a,b)=!(a^b)