poj 3295

[cpp]  view plain copy

1. /*代码一：自己构造栈*/  
2.   
3. //Memory Time  
4. //212K   79MS   
5.   
6. #include<iostream>  
7. using namespace std;  
8.   
9. int pp,qq,rr,ss,tt;  //各个逻辑变量的值  
10.   
11. typedef class STACK  
12. {  
13.     public:  
14.         int value;  
15.         class STACK* next;  
16.         STACK()  
17.         {  
18.             next=0;  
19.         }  
20. }Stack;  
21.   
22. typedef class Top  
23. {  
24.     public:  
25.         Stack* top;  
26.         Top()  
27.         {  
28.             top=0;  
29.         }  
30. }linkstack;  
31.   
32. void Insert(linkstack* s,int e);  //入栈  
33. int Pop(linkstack* s);  //栈顶值出栈  
34. void Empty(linkstack* s);  //清空栈  
35.   
36. bool isvariables(linkstack* s,char ch);  //判断ch是否为变量p q r s t，若是则把其当前值入栈  
37. void operators(linkstack* s,char op);   //根据操作符op对栈执行操作  
38. int K(int x,int y);  //and: x&&y  
39. int A(int x,int y);  //or : x||y  
40. int C(int x,int y);  //implies: (!x)||y  
41. int E(int x,int y);  //equals: x==y  
42. int N(int x);  //not: !x  
43.   
44. int main(void)  
45. {  
46.     linkstack* s=new linkstack[sizeof(linkstack)];  
47.   
48.     char WFF[110];  
49.     while(cin>>WFF && WFF[0]!='0')  
50.     {  
51.         int len=strlen(WFF);  //逻辑表达式的长度  
52.   
53.         bool flag=true;  //标记逻辑表达式是否为永真式  
54.         for(pp=0;pp<=1;pp++)  //枚举逻辑变量的值  
55.         {  
56.             for(qq=0;qq<=1;qq++)  
57.             {  
58.                 for(rr=0;rr<=1;rr++)  
59.                 {  
60.                     for(ss=0;ss<=1;ss++)  
61.                     {  
62.                         for(tt=0;tt<=1;tt++)  
63.                         {  
64.                             for(int pw=len-1;pw>=0;pw--)  
65.                             {  
66.                                 if(!isvariables(s,WFF[pw]))  
67.                                     operators(s,WFF[pw]);  
68.                             }  
69.   
70.                             int ans=s->top->value;   //最后栈剩一个值，即为逻辑表达式的值  
71.                             if(!ans)  //只要表达式有一个值为假，它就不是永真式  
72.                             {  
73.                                 flag=false;  
74.                                 break;  
75.                             }  
76.                             Empty(s);  
77.                         }  
78.                         if(!flag)  
79.                             break;  
80.                     }  
81.                     if(!flag)  
82.                         break;  
83.                 }  
84.                 if(!flag)  
85.                     break;  
86.             }  
87.             if(!flag)  
88.                 break;  
89.         }  
90.         if(flag)  
91.             cout<<"tautology"<<endl;  
92.         else  
93.             cout<<"not"<<endl;  
94.     }  
95.     return 0;  
96. }  
97.   
98. void Insert(linkstack* s,int e)  
99. {  
100.     Stack* node=new Stack[sizeof(Stack)];  
101.     node->value=e;  
102.     node->next=s->top;  
103.     s->top=node;  
104.   
105.     return;  
106. }  
107.   
108. int Pop(linkstack* s)  
109. {  
110.     int e=s->top->value;  
111.     Stack* temp=s->top;  
112.     s->top=s->top->next;  
113.     delete temp;  
114.   
115.     return e;  
116. }  
117.   
118. void Empty(linkstack* s)  
119. {  
120.     while(s->top)  
121.     {  
122.         Stack* temp=s->top;  
123.         s->top=s->top->next;  
124.         delete temp;  
125.     }  
126.     return;  
127. }  
128.   
129. bool isvariables(linkstack* s,char ch)  
130. {  
131.     switch(ch)  
132.     {  
133.         case 'p':Insert(s,pp);return true;  
134.         case 'q':Insert(s,qq);return true;  
135.         case 'r':Insert(s,rr);return true;  
136.         case 's':Insert(s,ss);return true;  
137.         case 't':Insert(s,tt);return true;  
138.     }  
139.     return false;  
140. }  
141.   
142. void operators(linkstack* s,char op)  
143. {  
144.     switch(op)  
145.     {  
146.         case 'K':  
147.             {  
148.                 int x=Pop(s);  
149.                 int y=Pop(s);  
150.                 Insert(s,K(x,y));  
151.                 break;  
152.             }  
153.         case 'A':  
154.             {  
155.                 int x=Pop(s);  
156.                 int y=Pop(s);  
157.                 Insert(s,A(x,y));  
158.                 break;  
159.             }  
160.         case 'C':  
161.             {  
162.                 int x=Pop(s);  
163.                 int y=Pop(s);  
164.                 Insert(s,C(x,y));  
165.                 break;  
166.             }  
167.         case 'E':  
168.             {  
169.                 int x=Pop(s);  
170.                 int y=Pop(s);  
171.                 Insert(s,E(x,y));  
172.                 break;  
173.             }  
174.         case 'N':  
175.             {  
176.                 int x=Pop(s);  
177.                 Insert(s,N(x));  
178.                 break;  
179.             }  
180.     }  
181.     return;  
182. }  
183.   
184. int K(int x,int y)  
185. {  
186.     return x&&y;  
187. }  
188.   
189. int A(int x,int y)  
190. {  
191.     return x||y;  
192. }  
193.   
194. int C(int x,int y)  
195. {  
196.     return (!x)||y;  
197. }  
198.   
199. int E(int x,int y)  
200. {  
201.     return x==y;  
202. }  
203.   
204. int N(int x)  
205. {  
206.     return !x;  
207. }