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

最新推荐文章于 2022-05-15 15:51:57 发布

原创最新推荐文章于 2022-05-15 15:51:57 发布 · 805 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

ACM

本文介绍了两种求解逻辑表达式是否恒为真的方法：一是使用递归计算表达式；二是利用前缀表达式结合栈结构进行计算。文章详细阐述了每种方法的实现步骤，并提供了完整的代码示例。

摘要：题意给定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;
}

标签

#poj