poj 3295 Tautology

题意：

输入由p、q、r、s、t、K、A、N、C、E共10个字母组成的逻辑表达式，

其中p、q、r、s、t的值为1（true）或0（false），即逻辑变量；

K、A、N、C、E为逻辑运算符，

K --> and: x && y

A --> or: x || y

N --> not : !x

C --> implies : (!x)||y

E --> equals : x==y

问这个逻辑表达式是否为永真式。

PS:输入格式保证是合法的

 这是道题感觉是对计算器进行模拟；

解题思路：

p, q, r, s, t不同的取值组合共32种情况，枚举不同取值组合代入逻辑表达式WFF进行计算。

如果对于所有的取值组合，WFF值都为 true, 则结果为 tautology，否则为 not。

WFF的计算方法：

从字符串WFF的末尾开始依次向前读取字符。

构造一个栈stack，当遇到逻辑变量 p, q, r, s ,t 则将其当前的值压栈；

遇到 N 则取栈顶元素进行非运算，运算结果的值压栈；

遇到K, A, C, E则从栈顶中弹出两个元素进行相应的运算，将结

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
#include<set>
#include<map>
#include<vector>
using namespace std;
class Node
{
 public:
        int num[4];
        int top;
 Node( ){top = -1;};    
};
int p,q,r,s,t;
void Insert( Node &Node_num ,int num )
{
   Node_num.num[++Node_num.top] = num;    
}
bool ischaracter( Node &Node_num,char c )
{
    switch( c )
    {
       case 'p':Insert( Node_num ,p );return true;
       case 'q':Insert( Node_num ,q );return true;
       case 'r':Insert( Node_num ,r );return true;
       case 's':Insert( Node_num ,s );return true;
       case 't':Insert( Node_num ,t );return true;    
    }
    return false;    
}
int Pop( Node &Node_num )
{
   return Node_num.num[Node_num.top--];    
}
int Opt_K( int x, int y )
{
       return x&&y;
}
int Opt_N( int x )
{
   return !x;    
}
int Opt_C( int x, int y )
{
   return (!x)||y;    
}
int Opt_A( int x, int y )
{
    return x||y;
}
int Opt_E(int x, int y)
{
   if( x==y ) return 1;
   else return 0;    
}
void Opt( Node &Node_num , char c )
{
   switch( c )
   {
      case 'K':Insert( Node_num ,Opt_K( Pop( Node_num ) ,Pop( Node_num )) );return;
      case 'N':Insert( Node_num ,Opt_N( Pop( Node_num ) ) );return;
      case 'C':Insert( Node_num ,Opt_C( Pop( Node_num ) ,Pop( Node_num )) );return;
      case 'A':Insert( Node_num ,Opt_A( Pop( Node_num ) ,Pop( Node_num )) );return;
      case 'E':Insert( Node_num ,Opt_E( Pop( Node_num ) ,Pop( Node_num )) );return;        
   }    
}
int main(  )
{
    char num[324];
    while( scanf( "%s",num ) ,num[0]!='0' )
    {
        Node Node_num,Node_opt;
        int flag = 1;
           int len = strlen( num );
        for(  p = 0 ; p <2&&flag  ; p ++ )
        {
           for(  q = 0 ; q < 2&&flag  ; q ++ )
           {
              for(  r = 0 ; r < 2&&flag  ; r ++ )
              {
                  for(  s = 0 ; s < 2&&flag  ; s ++ )
                  {
                      for(  t = 0 ; t < 2&&flag ; t ++ )
                      {
                          for( int i = len -1 ; i >=0 ; i -- )
                          {
                             if( !ischaracter( Node_num , num[i] ) )
                                 Opt( Node_num , num[i] );         
                          }
                          flag = Node_num.num[0];
                      }        
                  }        
              }        
           }    
        }
        if( flag ) printf( "tautology\n" );
        else printf( "not\n" );
    }
    //system( "pause" );
    return 0;
}

 

果的值压栈。

由于输入是合法的，当字符串WFF扫描结束时，栈stack中只剩一个值，该值就是逻辑表达式WFF的值。