构造发

本题中最多5个命题变项:p,q,r,s,t

每个有0,1两种取值,所以总共32种情况,分别枚举即可。

对于每种情况,计算表达式的值,如果有结果为0的则输出not

难点在于如何计算表达式的值,我们采用递归的方法,把表达式分为一或两个子表达式,并把参数end(本表达式的结束位置)传给上一层,一遍上一层获取第二个子表达式的起始位置。最后通过两个子表达式的结束位置,得到整个表达式的结束位置。

end是本表达式的最后一位的下标,即本表达式的长度减一。

所以 end = 2 + end1 + end2;

Sample Input

ApNp
ApNq
0

Sample Output

tautology
not
/*代码一:自己构造栈*/

//Memory Time
//212K   79MS 

#include<iostream>
using namespace std;

int pp,qq,rr,ss,tt;  //各个逻辑变量的值

typedef class STACK
{
    public:
        int value;
        class STACK* next;
        STACK()
        {
            next=0;
        }
}Stack;

typedef class Top
{
    public:
        Stack* top;
        Top()
        {
            top=0;
        }
}linkstack;

void Insert(linkstack* s,int e);  //入栈
int Pop(linkstack* s);  //栈顶值出栈
void Empty(linkstack* s);  //清空栈

bool isvariables(linkstack* s,char ch);  //判断ch是否为变量p q r s t,若是则把其当前值入栈
void operators(linkstack* s,char op);   //根据操作符op对栈执行操作
int K(int x,int y);  //and: x&&y
int A(int x,int y);  //or : x||y
int C(int x,int y);  //implies: (!x)||y
int E(int x,int y);  //equals: x==y
int N(int x);  //not: !x

int main(void)
{
    linkstack* s=new linkstack[sizeof(linkstack)];

    char WFF[110];
    while(cin>>WFF && WFF[0]!='0')
    {
        int len=strlen(WFF);  //逻辑表达式的长度

        bool flag=true;  //标记逻辑表达式是否为永真式
        for(pp=0;pp<=1;pp++)  //枚举逻辑变量的值
        {
            for(qq=0;qq<=1;qq++)
            {
                for(rr=0;rr<=1;rr++)
                {
                    for(ss=0;ss<=1;ss++)
                    {
                        for(tt=0;tt<=1;tt++)
                        {
                            for(int pw=len-1;pw>=0;pw--)
                            {
                                if(!isvariables(s,WFF[pw]))
                                    operators(s,WFF[pw]);
                            }

                            int ans=s->top->value;   //最后栈剩一个值,即为逻辑表达式的值
                            if(!ans)  //只要表达式有一个值为假,它就不是永真式
                            {
                                flag=false;
                                break;
                            }
                            Empty(s);
                        }
                        if(!flag)
                            break;
                    }
                    if(!flag)
                        break;
                }
                if(!flag)
                    break;
            }
            if(!flag)
                break;
        }
        if(flag)
            cout<<"tautology"<<endl;
        else
            cout<<"not"<<endl;
    }
    return 0;
}

void Insert(linkstack* s,int e)
{
    Stack* node=new Stack[sizeof(Stack)];
    node->value=e;
    node->next=s->top;
    s->top=node;

    return;
}

int Pop(linkstack* s)
{
    int e=s->top->value;
    Stack* temp=s->top;
    s->top=s->top->next;
    delete temp;

    return e;
}

void Empty(linkstack* s)
{
    while(s->top)
    {
        Stack* temp=s->top;
        s->top=s->top->next;
        delete temp;
    }
    return;
}

bool isvariables(linkstack* s,char ch)
{
    switch(ch)
    {
        case 'p':Insert(s,pp);return true;
        case 'q':Insert(s,qq);return true;
        case 'r':Insert(s,rr);return true;
        case 's':Insert(s,ss);return true;
        case 't':Insert(s,tt);return true;
    }
    return false;
}

void operators(linkstack* s,char op)
{
    switch(op)
    {
        case 'K':
            {
                int x=Pop(s);
                int y=Pop(s);
                Insert(s,K(x,y));
                break;
            }
        case 'A':
            {
                int x=Pop(s);
                int y=Pop(s);
                Insert(s,A(x,y));
                break;
            }
        case 'C':
            {
                int x=Pop(s);
                int y=Pop(s);
                Insert(s,C(x,y));
                break;
            }
        case 'E':
            {
                int x=Pop(s);
                int y=Pop(s);
                Insert(s,E(x,y));
                break;
            }
        case 'N':
            {
                int x=Pop(s);
                Insert(s,N(x));
                break;
            }
    }
    return;
}

int K(int x,int y)
{
    return x&&y;
}

int A(int x,int y)
{
    return x||y;
}

int C(int x,int y)
{
    return (!x)||y;
}

int E(int x,int y)
{
    return x==y;
}

int N(int x)
{
    return !x;
}
View Code

 

转载于:https://www.cnblogs.com/baoluqi/p/3745382.html

内容概要:本文详细介绍了施耐德M580系列PLC的存储结构、系统硬件架构、上电写入程序及CPU冗余特性。在存储结构方面,涵盖拓扑寻址、Device DDT远程寻址以及寄存器寻址三种方,详细解释了不同类型的寻址方法及其应用场景。系统硬件架构部分,阐述了最小系统的构建要素,包括CPU、机架和模块的选择与配置,并介绍了常见的系统拓扑结构,如简单的机架间拓扑和远程子站以太网菊花链等。上电写入程序环节,说明了通过USB和以太网两种接口进行程序下载的具体步骤,特别是针对初次下载时IP地址的设置方法。最后,CPU冗余部分重点描述了热备功能的实现机制,包括IP通讯地址配置和热备拓扑结构。 适合人群:从事工业自动化领域工作的技术人员,特别是对PLC编程及系统集成有一定了解的工程师。 使用场景及目标:①帮助工程师理解施耐德M580系列PLC的寻址机制,以便更好地进行模块配置和编程;②指导工程师完成最小系统的搭建,优化系统拓扑结构的设计;③提供详细的上电写入程序指南,确保程序下载顺利进行;④解释CPU冗余的实现方,提高系统的稳定性和可靠性。 其他说明:文中还涉及一些特殊模块的功能介绍,如定时器事件和Modbus串口通讯模块,这些内容有助于用户深入了解M580系列PLC的高级应用。此外,附录部分提供了远程子站和热备冗余系统的实物图片,便于用户直观理解相关概念。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值