布爾表達式

題目鏈接：http://noi.openjudge.cn/ch0303/6263/

總時間限制: 1000ms    內存限制: 65536kB

描述

輸入一個布爾表達式，請你輸出它的真假值。 比如：( V | V ) & F & ( F | V ) 
V表示true，F表示false，&表示與，|表示或，!表示非。 
上式的結果是F

輸入

輸入包含多行，每行一個布爾表達式，表達式中可以有空格，總長度不超過1000

輸出

對每行輸入，如果表達式為真，輸出"V",否則出來"F"

樣例輸入

( V | V ) & F & ( F| V)
!V | V & V & !F & (F | V ) & (!F | F | !V & V)
(F&F|V|!V&!F&!(F|F&V))

樣例輸出

F
V
V

分析：（來源：http://blog.csdn.net/INCINCIBLE/article/details/51151222?locationNum=5&fps=1）

原理很簡單，將中綴表達式轉化為前綴表達式在計算，只是代碼實現比較麻煩。

中綴轉前綴的步驟如下：

(1) 首先構造一個運算符棧(也可放置括號)，運算符(以括號分界點)在棧內遵循越往棧頂優先級不降低的原則進行排列。

(2)從右至左掃描中綴表達式，從右邊第一個字符開始判斷：

如果當前字符是數字，則分析到數字串的結尾並將數字串直接輸出。

如果是運算符，則比較優先級。如果當前運算符的優先級大於等於棧頂運算符的優先級(當棧頂是括號時，直接入棧)，則將運算符直接入棧；否則將棧頂運算符出棧並輸出，直到當前運算符的優先級大於等於棧頂運算符的優先級(當棧頂是括號時，直接入棧)，再將當前運算符入棧。

如果是括號，則根據括號的方向進行處理。如果是右括號，則直接入棧；否則，遇左括號前將所有的運算符全部出棧並輸出，遇右括號后將左右的兩括號一起刪除。

(3) 重復上述操作(2)直至掃描結束，將棧內剩余運算符全部出棧並輸出，再逆綴輸出字符串。中綴表達式也就轉換為前綴表達式了。

 

右括號有最高的優先級，左括號優先級最低。

代碼：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<stack>
#include<cstring>
using namespace std;
char calculate(char x, char y,char oper )// 計算 x oper y 
{
    bool a=(x=='V'),b=(y=='V'),ans;
    if(oper=='|') ans=(a||b);
    else if(oper=='&') ans=(a&&b);
    return ans?'V':'F';
}
char reverse(char x) //將邏輯值取反。其實就是‘！’運算符 
{
    if(x=='V')return 'F';
    return 'V';
}
int main()
{
    string in;
    int i,j,len;
    
    while(getline(cin,in))
    {
        stack<char> Oper,num; //oper保存運算符，num保存運算結果 
        queue<char> s;        //s就是前綴表達式 
        len=in.length();
        i=len;
        in=" "+in;
        while(i>0)// 從右往左，中綴表達式轉前綴表達式 
        {
            if(in[i]==' ')
            {
                i--;continue;
            }
            else if(isalpha(in[i])) s.push(in[i--]);//isalpha()函數：如果參數是字母字符，函數返回非零值，否則返回零值
            else if(in[i]=='!')  s.push(in[i--]);    //最高級的運算，直接進入表達式(這里主要是因為！運算符是單目運算符) 
            else
            {
                if(in[i]=='&'||in[i]=='|'||in[i]==')')  //低級運算，進棧 
                    Oper.push(in[i--]);
                else if(in[i]=='(')  //一個括號結束，彈出中間的所有運算符 
                {  
                    while(Oper.top()!=')')
                    {
                        s.push(Oper.top());
                        Oper.pop();
                    }
                    Oper.pop();
                    i--;
                }
            }
        }
        while(!Oper.empty())  //棧中剩下的運算符 
            s.push(Oper.top()),Oper.pop();
        
        while(!s.empty())  //計算前綴表達式 
        {       
            char ch=s.front(); s.pop();
            if(isalpha(ch))  num.push(ch);
            else Oper.push(ch);
            if(!num.empty()&&!Oper.empty()&&Oper.top()=='!')  //單目運算符‘！’；
            {   
                char x=num.top();
                num.pop();Oper.pop();
                num.push(reverse(x));
            }
            else if(num.size()>=2&&!Oper.empty())  //雙目運算符 
            {
                char oper=Oper.top(),x,y;
                Oper.pop();
                x=num.top();num.pop();
                y=num.top();num.pop();
                num.push(calculate(x,y,oper));
            }
        }
        cout<<num.top()<<endl;
    }
}

 

另外，可以參考http://www.ithao123.cn/content-10400535.html

 第二種思路，遞歸求解。

代碼來源：北大郭煒老師MOOC課程的代碼。可以參考中綴表達式計算這篇文章的分析。

#include <iostream>
#include <cstdio>
using namespace std;

char wholeExp[1500];//表示整個表達式的字符串 
int ptr = 0;

bool exp();//讀入一個表達式並返回其值 
bool item();//讀入一個項並返回其值 
bool factor();//讀入一個因子並返回其值 
bool notExp();//將表達式取反的操作
/*
表達式：由單獨的"項"或者"項"與"|"運算符連接形成；
項：由單獨的"因子"或"因子"和&運算符連接而成；
因子：可以是單獨的V或F，也可以是用括號括起來的"表達式"。
*/
int main()
{
    freopen("6263.in","r",stdin);
    int t = 1;//表示第t個測試樣例 
    char c;
    int i = 0;
    int n = EOF + 1;
    while(n != EOF) 
    {
        n = scanf("%c",&c);
        if( n == EOF || c == '\n') 
        {
            wholeExp[i] = '\0';
            if( i > 0) 
            {
                ptr = 0;
                bool res = exp();
                if (res) { printf("Expression %d: V\n",t++); }
                else printf("Expression %d: F\n",t++);
                /*if (res) { printf("V\n",t++); }
                else printf("F\n",t++);*/
            }
            i = 0;
        }
        else if( c != ' ') wholeExp[i++] = c;
    }
    return 0;
}

bool exp() //讀入一個表達式並返回其值 
{
    bool result = item();
    while(wholeExp[ptr] == '|' ) 
    {
        ++ptr;
        result = result | item();//注意：這里的或運算不能用C語言邏輯或運算符，因為邏輯或運算符在編譯器處理完以后有短路特性，可能會忽略后面的輸入。比如(V|V)&F，若是用邏輯或，可能只掃描到第一個V就返回邏輯真，不再繼續往后掃描了。但是其實應該是邏輯假。  53     }
    return result;
}

bool item() //讀入一個項並返回其值  
{
    bool result = factor();
    while(wholeExp[ptr] == '&') 
    {
        ++ptr;
        result = result & factor();//同樣地，這個地方不能用邏輯與運算符，否則會錯忽略后面應該掃描的東西從而返回錯誤的結果。比如(F&V)|V。  64     }
    return result;
}

bool factor() //讀入一個因子並返回其值 
{
    bool result;
    switch( wholeExp[ptr]) 
    {
        case 'F':
            ++ptr;
            return false;
            break;
        case 'V':
            ++ptr;
            return true;
            break;
        case '(':
            ++ptr;
            result = exp();
            ++ptr; //skip ')'
            return result;
            break;
        case '!':
            result = notExp();
            return result;
            break;
    }
}

bool notExp() //將表達式取反的操作
{
    //wholeExp[ptr] == '!' when called;
    ptr++;
    bool result;
    switch(wholeExp[ptr]) 
    {
        case 'F':
            ++ptr;
            return true;
            break;
        case 'V':
            ++ptr;
            return false;
            break;
        case '(':
            ++ptr;
            result = exp();
            ++ptr; //skip ')'
            return !result;
            break;
        case '!':
            result = notExp();
            return !result;
            break;
    }
}