POJ 3295 -Tautology

最新推荐文章于 2019-04-26 12:28:10 发布

原创最新推荐文章于 2019-04-26 12:28:10 发布 · 947 阅读

0 ·

CC 4.0 BY-SA版权

Poj 专栏收录该内容

42 篇文章

订阅专栏

本文探讨离散数学中的构造法，通过实例解析如何利用栈实现特定逻辑运算，强调了从理论到实践的转化过程及自我学习的重要性。

考察离散数学基础，构造法

不过，说实话这道题我不会，代码也在网上看的别人的题解，提交了也过了，但是没什么快感，毕竟是看了别人的代码，，终归揭底，还是自己太渣。这题想了好久，道理明白，但是不会代码实现，看别人的理解之后，自己一个一个敲的，我自己估计想到明天也想不出来用栈来实现，很棒的思路，应该好好学习一下

蕴含 1->0 时为假，其余都为真

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <algorithm>
const int INF = 1e8;
const int N = 1100;
#define ll long long
char a[N+1];
int st[N+1];
using namespace std;
int main()
{
    int len,l,flag;
    while(~scanf("%s",a))
    {
        if(strcmp(a,"0")==0)
            break;
        flag = 1;
        len = strlen(a);
        l = 0;
        for(int p = 0;p<=1;p++)
        {
            if(flag==0)break;
            for(int q = 0;q<=1;q++)
            {
                if(flag==0)break;
                for(int r = 0;r<=1;r++)
                {
                    if(flag==0)
                        break;
                    for(int s = 0;s<=1;s++)
                    {
                        if(flag==0)
                        break;
                        for(int t = 0;t<=1;t++)
                        {
                            if(flag==0)
                            break;
                             l = 0;
                           for(int i = len - 1;i>=0;i--)
                           {
                            if(a[i]=='p') 
                                st[l++] = p;
                            if(a[i]=='q') 
                            st[l++] = q;
                            if(a[i]=='r') 
                                st[l++] = r;
                            if(a[i]=='s') 
                            st[l++] = s;
                            if(a[i]=='t') 
                                st[l++] = t;
                            if(a[i]=='K') 
                                {
                                    --l;
                            st[l-1] = (st[l-1] && st[l]);
                                }
                            if(a[i]=='A') 
                            {
                                --l;
                            st[l-1] = (st[l-1] || st[l]);
                            }
                            if(a[i]=='N') 
                                st[l-1] = !st[l-1];
                            if(a[i]=='C') 
                                {
                                    --l;
                            st[l-1] = ((!st[l-1])||st[l]);
                                }
                            if(a[i]=='E') 
                                {
                                    --l;
                            st[l-1] = (st[l-1]==st[l]);
                                }
                           }
                           if(l!=1 || st[l-1]!=1)
                           {
                               flag = 0;break;
                           }
                        }
                    }
                }
            }
        }
        (flag==1)?puts("tautology"):puts("not");
    }
    return 0;
}