Tautology - poj 3295

Time Limit: 1000MS   Memory Limit: 65536K
Total Submissions: 10437   Accepted: 3963

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

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

p,q,r,s,t,是五个二进制数。

K,A,N,C,E,是五个运算符。

K:&&

A:||
N:!

C:(!w)||x

E:w==x

这道题可以将p,q,r,s,t穷举

  1 #include <iostream>
  2 #include<string.h>
  3 #include <stack>
  4 using namespace std;
  5 int p, q, r, s, t;
  6 int len;
  7 char str[106];
  8 int result() {
  9     stack<int> res;
 10     int t1,t2;
 11     for (int i = len - 1; i >= 0; i--) {
 12         switch (str[i]) {
 13         case ‘p‘:
 14             res.push(p);
 15             break;
 16         case ‘q‘:
 17             res.push(q);
 18             break;
 19         case ‘r‘:
 20             res.push(r);
 21             break;
 22         case ‘s‘:
 23             res.push(s);
 24             break;
 25         case ‘t‘:
 26             res.push(t);
 27             break;
 28         case ‘K‘:
 29             t1 = res.top();
 30             res.pop();
 31             t2 = res.top();
 32             res.pop();
 33             if (t1 & t2) {
 34                 res.push(1);
 35             } else {
 36                 res.push(0);
 37             }
 38             break;
 39         case ‘A‘:
 40             t1 = res.top();
 41             res.pop();
 42             t2 = res.top();
 43             res.pop();
 44             if (t1 | t2)
 45                 res.push(1);
 46             else
 47                 res.push(0);
 48             break;
 49         case ‘N‘:
 50             t1 = res.top();
 51             res.pop();
 52             if (~t1 & 1)
 53                 res.push(1);
 54             else
 55                 res.push(0);
 56             break;
 57         case ‘C‘:
 58             t1 = res.top();
 59             res.pop();
 60             t2 = res.top();
 61             res.pop();
 62             if ((~t1 & 1) | t2) {
 63                 res.push(1);
 64             } else {
 65                 res.push(0);
 66             }
 67             break;
 68         case ‘E‘:
 69             t1 = res.top();
 70             res.pop();
 71             t2 = res.top();
 72             res.pop();
 73             if (t1 == t2) {
 74                 res.push(1);
 75             } else {
 76                 res.push(0);
 77             }
 78             break;
 79         }
 80     }
 81     return res.top();
 82 }
 83
 84 int fun() {
 85     int flag;
 86     for (p = 0; p < 2; p++) {
 87         for (q = 0; q < 2; q++) {
 88             for (r = 0; r < 2; r++) {
 89                 for (s = 0; s < 2; s++) {
 90                     for (t = 0; t < 2; t++) {
 91                         flag = result();
 92                         if(flag==0)
 93                             return 0;
 94                     }
 95                 }
 96             }
 97         }
 98     }
 99     return 1;
100 }
101
102 int main() {
103     while (cin >> str) {
104         if (strcmp(str, "0") == 0)
105             break;
106         len = strlen(str);
107         int flag=fun();
108         if(flag)
109             cout<<"tautology"<<endl;
110         else
111             cout<<"not"<<endl;
112     }
113 }
时间: 2024-08-29 21:12:34

Tautology - poj 3295的相关文章

[ACM] POJ 3295 Tautology (构造)

Tautology Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 9302   Accepted: 3549 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,

[ACM] POJ 3295 Ubiquitous Religions (并查集)

Ubiquitous Religions Time Limit: 5000MS   Memory Limit: 65536K Total Submissions: 23093   Accepted: 11379 Description There are so many different religions in the world today that it is difficult to keep track of them all. You are interested in findi

poj 3295 Tautology 伪递归

题目链接: http://poj.org/problem?id=3295 题目描述: 给一个字符串,字符串所表示的表达式中p, q, r, s, t表示变量,取值可以为1或0.K, A, N, C, E 分别表示且,或,非,真蕴含,等值.问表达式是不是永真的,如果是输出“tautology”,否则输出“not”. 解题思路: 这里借用到了递归的本质,也就是对栈的模拟,用递归进行压栈,求表达式的值,再加上对变量状态压缩进行枚举. 1 #include <cstdio>//本代码用G++交就ac,

POJ 3295 Tautology (栈模拟)

Tautology Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 10096   Accepted: 3847 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

POJ 3295 Tautology(构造法)

题目网址:http://poj.org/problem?id=3295 题目: Tautology Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 13231   Accepted: 5050 Description WFF 'N PROOF is a logic game played with dice. Each die has six faces representing some subset of the po

POJ - 3295 - Tautology = 枚举 + 二叉树遍历

http://poj.org/problem?id=3295 题意:给若干个小写字母表示bool变量,大写字母表示bool运算,求这个表达式的是否为永真表达式. 输入形如: ApNp ApNq 也就是前缀表达式. 所以就写个东西遍历它构造一棵树,然后给同名变量枚举赋值,假如没有任何赋值使得树根输出0,则为永真表达式. 考察二叉树的递归遍历. #include<algorithm> #include<cmath> #include<cstdio> #include<

poj 3295 Tautology [ 栈 ]

传送门 Tautology Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 10107   Accepted: 3850 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,

poj 3295 Tautology

这题属于构造题,有两点需要想到: 1.所谓永真式就是说题设中所给的五个逻辑变量无论如何取值,最终的运算结果总是为真,这里就需要枚举五个逻辑变量的取值情形.很容易想到共有32种情况: 也就是说,对于每个字符串,如果这32种情况下的运算结果都是真的话, 那它就是永真式.1~32, 用按位与的办法,可以逐次枚举这32中情况. 2.运算顺序:可以这样理解题目中的字符串结构,它就像一颗树,所以叶子节点做逻辑运算之后逐次汇聚到根节点得到最后的结果.于是想到从尾部开始(也就是从叶节点向上). 如果遇到逻辑变量

POJ - 3295 - Tautology (构造)

题目传送:Tautology 思路:枚举所有变量可能的值(0或1),算出其表达式的值,因为题目是要求是否是永真式,求式子的真值可以用栈来求,栈的话,可以自己构造一个栈,也可以用STL的stack AC代码: #include <cstdio> #include <cstring> #include <iostream> #include <algorithm> #include <cmath> #include <queue> #in