POJ-3295 Tautology

Tautology

Time Limit: 1000MS
Memory Limit: 65536K

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:

1. p, q, r, s, and t are WFFs
2. if w is a WFF, Nw is a WFF
3. 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.

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

Reference Code

#include <cstdio>
#include <cstring>
#include <set>
#include <map>
#include <stack>
using namespace std;
const int maxn=100+10;
set<char> state;
set<char>::iterator iter1;
map<char,bool> mp;
map<char,bool>::iterator iter2;
char wff[maxn];
int len;
bool calc(int x){
    mp.clear();
    int j=0;
    for (iter1=state.begin();iter1!=state.end();++iter1)
        mp.insert(make_pair(*iter1,x&(1<<j++)));
    stack<bool> s;
    for (int i=len-1;i>=0;--i){
        if (wff[i]>='a'){
            iter2=mp.find(wff[i]);
            s.push(iter2->second);
        }
        else{
            bool b2=s.top();s.pop();
            if (wff[i]=='N'){
                s.push(!b2);
                continue;
            }
            bool b1=s.top();s.pop();
            if (wff[i]=='K') s.push(b1&&b2);
            else if (wff[i]=='A') s.push(b1||b2);
            else if (wff[i]=='C') s.push((!b1)||b2);
            else if (wff[i]=='E') s.push(b1==b2);
        }
    }
    return s.top();
}
bool Judge(){
    state.clear();
    len=strlen(wff);
    for (int i=0;i<len;++i)
        if (wff[i]>='a')
            state.insert(wff[i]);
    for (int i=0;i<(1<<state.size());++i)
        if (!calc(i)) return false;
    return true;
}
int main(){
    while (~scanf("%s",wff)){
        if (wff[0]=='0') break;
        if (Judge()) printf("tautology\n");
        else printf("not\n");
    }
    return 0;
}

Tips

估计数据比较水，暴力也能过了。
首先，合式公式的计算可以像表达式计算一样用栈来解决；
其次，对于每一个命题变元的真值指派可以利用二进制数方便的表示；
最后，如果在一种真值指派下合式公式为否，则立即退出，减少计算次数。

学完离散再来看这条真的特别亲切啊。