题目大意：F表示0，V表示1。通过逻辑运算得出最后答案是真还是假，真输出V，假输出F。
思路：通过栈，将原式处理为后缀表达式，然后进行计算。
后缀表达式又叫逆波兰表达式：
这里可以通过优先级不同来构建一个后缀表达式。
将'！'的优先级定为3级，'&'定为2级，'|'定为1级（级别越大，优先级越高）
写入的时候用queue构建一个后缀表达式。用stack暂时存储运算符号。
对于F和V直接存入queue
对于符号：
stack存储原则：按照优先级从低到高放入，如果下一个将要放入的符号的优先级低于最后一个存入stack的符号的优先级，那么就将stack存入的符号依次取出并存入queue，直到满足优先级从低到高排列。
例如：
V|V|V&F&!V|F&V&V|F
1：V
将V存入queue
queue：V
stack：
2：|
将|存入stack
queue：V
stack：|
3：V
将V存入queue
queue：VV
stack：|
4：|
由于stack的优先级不满足，将stack的|取出放入queue（此时stack已空），将此时的|放入stack
queue：VV|
stack：|
5：V
将V存入queue
queue：VV|V
stack：|
6：&
将&存入stack(&的优先级高于|)
queue：VV|V
stack：|&
7：F
将F存入queue
queue：VV|VF
stack：|&
8：&
将stack的&取出并放入queue，然后满足优先级低高顺序，再将现在的&放入stack
queue：VV|VF&
stack：|&
9：！
将！放入stack（！的优先级高于&）
queue：VV|VF&
stack：|&！
10：V
将V存入queue
queue：VV|VF&V
stack：|&！
11：|
由于|优先级低于！且低于&且低于|
queue：VV|VF&V！&|
stack：|
…………
最后可以得到：
VV|VF&V!&|FV&V&|F| (后缀表达式构建完成)
第二步：用stack计算后缀表达式
push（V）
stack:V
push（V）
stack:VV
x=pop（）且y=pop（） res=x||y 将res换成V（F）再push(res)
stack:(V||V)
push（V）
stack:(V||V)V
push（F）
stack:(V||V)VF
x=pop（）且y=pop（） res=x&&y 将res换成V（F）再push(res)
stack:(V||V)(V&&F)
push（V）
stack:(V||V)(V&&F)V
x=pop（） res=!x 将res换成V（F）再push(res)
stack:(V||V)(V&&F)(!V)
x=pop（）且y=pop（） res=x&&y 将res换成V（F）再push(res)
stack:(V||V)((V&&F)&&(!V))
x=pop（）且y=pop（） res=x||y 将res换成V（F）再push(res)
stack:((V||V)||((V&&F)&&(!V)))
push（F）
stack:((V||V)||((V&&F)&&(!V)))F
push（V）
stack:((V||V)||((V&&F)&&(!V)))FV
x=pop（）且y=pop（） res=x&&y 将res换成V（F）再push(res)
stack:((V||V)||((V&&F)&&(!V)))(F&&V)
push（V）
stack:((V||V)||((V&&F)&&(!V)))(F&&V)V
x=pop（）且y=pop（） res=x&&y 将res换成V（F）再push(res)
stack:((V||V)||((V&&F)&&(!V)))((F&&V)&&V)
x=pop（）且y=pop（） res=x||y 将res换成V（F）再push(res)
stack:((V||V)||(((V&&F)&&(!V)))||((F&&V)&&V))
push（F）
stack:((V||V)||(((V&&F)&&(!V)))||((F&&V)&&V))F
x=pop（）且y=pop（） res=x||y 将res换成V（F）再push(res)
stack:((V||V)||(((V&&F)&&(!V)))||((F&&V)&&V))||F
最后对比下V|V|V&F&!V|F&V&V|F会发现结果和预期一样
总结：
构建后缀表达式：
①对于字母：直接推入queue
②对于运算符：
Ⅰ.按照运算符的高低级 由低到高推入stack
Ⅱ.若不满足就从stack依次取出最后一个运算符，并推入queue，直到满足运算符的高低级顺序，再将此时的运算符推入stack
计算后缀表达式：
从queue依次取出：
①如果为字母，直接推入stack
②如果为运算符：
Ⅰ.运算符为！，则从stack取出最后一个字母，计算！x后，再推入stack
Ⅱ.运算符为|或&，则从stack取出最后两个字母，计算x&&y后，再推入stack
对于此题，比较后会发现，此题多了个'（'和'）'
于是再加一个判别条件：
当此时a[i]=')'时，取出存储运算符的stack的最后一个运算符并存入queue，依次重复本操作，直到遇见'('
if(a[i]==')')
{
while(s.top()!='(')
{
q.push(s.top());
s.pop();
}
s.pop();
}
此题完整代码：
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<stack>
#include<queue>
#include<cstring>
using namespace std;
char a[10010];
stack<char> s;//save operation symbol
queue<char> q;//suffix expression
int f(char x)//'V'or'F'?
{
if(x=='V') return 1;
else return 0;
}
int op(char c)//priority
{
if(c=='(') return 4;
if(c=='!') return 3;
if(c=='&') return 2;
if(c=='|') return 1;
}
void Clear()
{
while(s.size())
{
s.pop();
}
}
void init(int len)
{
int i;
Clear();
for(i=0; i<len; i++)
{
if(a[i]!=' ')
{
if(a[i]=='F' || a[i]=='V') q.push(a[i]);
else if(a[i]=='!' && s.size() && s.top()=='!') s.pop(); //Two '!'
else if(!s.size()) s.push(a[i]);
else if(a[i]==')')
{
while(s.top()!='(')
{
q.push(s.top());
s.pop();
}
s.pop();
}
else if(op(s.top())==4 || (op(a[i])>op(s.top()))) s.push(a[i]);//'(' is first input last output
else if(op(s.top())!=4 && (op(a[i])<=op(s.top())))
{
q.push(s.top());
s.pop();
while(s.size() && op(s.top())!=4 && op(a[i])<=op(s.top()))
{
q.push(s.top());
s.pop();
}
s.push(a[i]);
}
}
}
while(s.size())
{
q.push(s.top());
s.pop();
}
}
void sum()
{
char x, y, temp;
bool res=1;
while(q.size())
{
temp=q.front();
if(temp=='V' || temp=='F')
{
s.push(temp);
q.pop();
}
else if(temp=='&')
{
x=s.top();
s.pop();
y=s.top();
s.pop();
res=f(x)&&f(y);
if(res==1) s.push('V');
else s.push('F');
q.pop();
}
else if(temp=='|')
{
x=s.top();
s.pop();
y=s.top();
s.pop();
res=f(x)||f(y);
if(res==1) s.push('V');
else s.push('F');
q.pop();
}
else if(temp=='!')
{
x=s.top();
s.pop();
if(f(x)==1) s.push('F');
else s.push('V');
q.pop();
}
}
}
int main()
{
int cnt=1, len;
while(gets(a)!=NULL)
{
len=strlen(a);
init(len);
sum();
printf("Expression %d: %c\n", cnt++, s.top());
}
return 0;
}
