poj3295(前缀表达式的运用和递归求解表达式)解题报告

摘要：题意给定5个运算符 A,K,E,N,C（每个都代表一种逻辑运算）,再给定5个逻辑变量(pqrst)，输入一个逻辑表达式,判断该表达式是不是恒为真表达式.

[1]首先给出第一种思路:使用递归的方法去计算相应的表达式.从左到右扫描表达式,如果它是一个运算符(N),那么就检测它的下一个字符，如果该字符是一个运算符号,递归的去计算它，最后返回一个逻辑值.如果该字符是一个逻辑变量,则直接返回该变量对应的逻辑值.

[2]如果这个运算符是（A K E C）,那么我们就需要计算两次它操作的逻辑变量.方法同1.需要注意的是,字符串下标.比如（ANpp）里面,我们首先计算了A,发现它的下一个字符是N,然后递归的下降到N,发现N的下一个字符可以直接取得.计算后返回到A，这时候需要计算A的第二个操作数，因此指针也应该指向p,因为第一个p的下一个字符是第二个p.这个在代码里稍加注意即可.

[3]为了简化代码的结构,我们绝不采取5次循环来枚举逻辑变量,而是利用一个0到31的循环,每次传入一个整数i,假设pqsrt是二进制的第01234位,通过检查这个整数的第k位进行赋值.这样只需要计算存在表达式里面的逻辑变量,而不需要每次都把所有逻辑变量都计算一遍了.

#include "stdafx.h"
#include "iostream"
#include "cstring"
using namespace std;
char S[101];
int top = 0;
bool p,q,r,s,t;
bool choose(char c,int i)
{
switch(c)
{
{
case 'p':  return ((i&(1<<4)) ?true:false) ;break;
case 'q':  return ((i&(1<<3)) ?true:false);break;
case 'r':  return  ((i&(1<<2)) ?true:false);break;
case 's':  return  ((i&(1<<1)) ?true:false);break;
case 't':  return  ((i&(1<<0)) ?true:false);break;
}
}
}
bool compute(char c,char x,char y)
{
switch(c)
{
case 'K':  return x&y;break;
case 'A':  return x|y;break;
case 'N':  return !x;break;
case 'C':  return (!x)|y;break;
case 'E':  return (x==y);break;
}
}
bool isvariable(char c)
{
if(c=='p'||c == 'q'||c == 'r'||c == 's'||c == 't')
return true;
return false;
}
bool expression(int i)
{
bool s1,s2;
char C = S[top];
if(S[top] == 'N')
{
if(isvariable(S[top+1]))
{
s1 = choose(S[top+1],i);
top++;
}
else
{
top++;
s1 = expression(i);
}
return compute(C,s1,true);
}
else if(S[top] == 'A'||S[top] == 'K'||S[top] == 'C'||S[top] == 'E')
{
if(isvariable(S[top+1]))
{
s1 = choose(S[top+1],i);
top++;
}
else
{
top++;
s1 = expression(i);
}
if(isvariable(S[top+1]))
{
s2 = choose(S[top+1],i);
top++;
}
else
{
top++;
s2 = expression(i);
}
return compute(C,s1,s2);
}
}
int main()
{
int x = 8&(1<<3);
while(cin>>S)
{
if(S[0] == '0')
break;
int i;//用来枚举pqrst
for( i = 0;i<=31;i++)
{
top = 0;
if(expression(i) == false)
{
cout<<"not"<<endl;
break;
}
}
if(i == 32)
cout<<"tautology"<<endl;
memset(S,0,sizeof(S));
}
return 0;
}

下面给出思路二,利用前缀表达式去计算.

【1】前缀表达式是从右到左扫描表达式,如果是一个操作数,直接入栈,不是则根据相应的操作符弹出一个或者两个操作数,然后计算结果再压入栈.最后栈为空.利用了STL里面的栈.这种思路代码要更简洁,逻辑结构也更好.

#include "stdafx.h"
#include "iostream"
#include <stack>
using namespace std;
stack<bool> s;
bool isvariable(char c,int i)//在判断的时候就把相应的bool值分配好
{
switch(c)
{
case 'p':  s.push((i&(1<<4)) ?true:false) ;return true;break;
case 'q':  s.push((i&(1<<3)) ?true:false);return true;break;
case 'r':  s.push((i&(1<<2)) ?true:false);return true;break;
case 's':  s.push((i&(1<<1)) ?true:false);return true;break;
case 't':   s.push((i&(1<<0)) ?true:false);return true;break;
}
return false;
}
void compute(char c)
{
bool s1,s2;
switch(c)
{
case 'N' : s1 = s.top();s.pop();s.push(!s1);break;
case 'A' : s1 = s.top();s.pop();s2 = s.top();s.pop();s.push(s1|s2);break;
case 'K' : s1 = s.top();s.pop();s2 = s.top();s.pop();s.push(s1&s2);break;
case 'E' : s1 = s.top();s.pop();s2 = s.top();s.pop();s.push(s1==s2);break;
case 'C' : s1 = s.top();s.pop();s2 = s.top();s.pop();s.push((!s1)|s2);break;
}
}
int _tmain(int argc, _TCHAR* argv[])
{
int i;
char WFF[101];
while(cin>>WFF)
{
if(WFF[0] == '0')
break;

for(i = 0;i<=31;i++)
{
int len = strlen(WFF);
for(int k = len-1;k>=0;k--)
{
if(!isvariable(WFF[k],i))//不是逻辑变量,那就是运算符号
compute(WFF[k]);
}
bool ans = s.top();
s.top();
if(ans == false)
{
cout<<"not"<<endl;
break;
}
}
if(i==32)
cout<<"tautology"<<endl;
memset(WFF,0,sizeof(WFF));
}
return 0;
}