【Openjudge】表达式·表达式树·表达式求值

#include<iostream>
#include<stack>
#include<map>
#include<queue>
#include<string>

using namespace std;

bool compare(char c, char c_in_stack){
if (c == '*' || c == '/'){
if (c_in_stack == '+' || c_in_stack == '-')
return true;
}
return false;
}

int main()
{
string s, revs;
map<char, int> variable_dic;
int variable_num;

cin >> s;
cin >> variable_num;
for (int i = 0; i < variable_num; i ++){
char c; int t;
cin >> c >> t;
variable_dic[c] = t;
}

//make the string to a RPN(reverse polish notation)
int length = s.length();
stack<char> trans;
for (int i = 0; i < length; i ++){
if (s[i] >= 'a' && s[i] <= 'z'){
revs.push_back(s[i]);
}
else if (s[i] == '(' || trans.empty()){
trans.push(s[i]);
}
else if (s[i] == ')'){
while(trans.top() != '('){
revs.push_back(trans.top());
trans.pop();
}
trans.pop();
}
else{
if (compare(s[i], trans.top())){
trans.push(s[i]);
}
else{
while (!trans.empty()  && trans.top() != '(' && !compare(s[i], trans.top())){
revs.push_back(trans.top());
trans.pop();
}
trans.push(s[i]);
}
}
}
while(!trans.empty()){
revs.push_back(trans.top());	trans.pop();
}

cout << revs << endl;

//compute the depth and build the tree and compute the answer
//node of the tree
struct _node{
char data;
_node *left;
_node *right;
int depth;
_node(char d = 0, _node *l = NULL, _node *r = NULL):data(d), left(l), right(r){
if (left){
if (right){
depth = left->depth > right->depth ? left->depth:right->depth;
}
else{
depth = left->depth;
}
}
else{
if (right){
depth = right->depth;
}
else{
depth = -1;
}
}
depth ++;
};
};
class computer{
public:
int operator()(int a, int b, char c){
switch(c){
case '+':
return a + b;
case '-':
return a - b;
case '*':
return a * b;
case '/':
return a / b;
default:
return 1;
}
}
};

//breadth first traversal
class bftravel{
public:
int power(int a, int b){
int ans = 1;
for (int i = 0; i < b ; i ++){
ans *= a;
}
return ans;
}
void operator()(_node* root){
struct node_with_depth{
_node *pointer;
int pos;
node_with_depth(_node* p = NULL, int d = 0):pointer(p), pos(d){};
};
int max_depth = root->depth;
queue<node_with_depth> draw;
node_with_depth draw_ele(root, power(2, max_depth));
draw.push(draw_ele);
while (!draw.empty()){
string s(power(2, max_depth + 1) + 1, ' ');
string sbar(power(2, max_depth + 1) + 1, ' ');
int depth = draw.front().pointer->depth;
while(!draw.empty() && depth == draw.front().pointer->depth){
draw_ele = draw.front();
draw.pop();
s[draw_ele.pos - 1] = draw_ele.pointer->data;
if (draw_ele.pointer->left){
sbar[draw_ele.pos - 2] = '/';
draw_ele.pointer->left->depth = depth - 1;
draw.push(node_with_depth(draw_ele.pointer->left, draw_ele.pos - power(2,draw_ele.pointer->depth - 1)));
}
if (draw_ele.pointer->right){
sbar[draw_ele.pos] = '\\';
draw_ele.pointer->right->depth = depth - 1;
draw.push(node_with_depth(draw_ele.pointer->right, draw_ele.pos + power(2, draw_ele.pointer->depth - 1)));
}
}
s[draw_ele.pos] = 0;
if (draw.empty()){
sbar[0] = 0;
}
else{
int i = draw_ele.pos + 2;
while (sbar[i] == ' ')
sbar[i --] = 0;
sbar[i + 1] = '\n';
}
cout << s.c_str() << endl << sbar.c_str();
}
}
};

stack<_node*> compute_stack;
stack<int> compute_ans;
_node *pointer;
length = revs.length();

//build the tree and compute the answer for the formula
for (int i = 0; i < length; i ++){
if (revs[i] >= 'a' && revs[i] <= 'z'){
pointer = new _node(revs[i]);
compute_stack.push(pointer);
compute_ans.push(variable_dic[revs[i]]);
}
else{
_node *right_child = compute_stack.top();	compute_stack.pop();
_node *left_child = compute_stack.top();	compute_stack.pop();
pointer = new _node(revs[i], left_child, right_child);
compute_stack.push(pointer);

int b = compute_ans.top(); compute_ans.pop();
int a = compute_ans.top(); compute_ans.pop();
compute_ans.push(computer()(a, b, revs[i]));
}
}

bftravel()(pointer);
cout << compute_ans.top() << endl;
return 0;
}