Sicily 1139. 电路稳定性

1139. 电路稳定性

Constraints

Time Limit: 1 secs, Memory Limit: 32 MB

Description

zzz有一个电路，电路上有n个元件。已知元件i损坏而断开的概率是Pi(i=1，2，...，n，0≤Pi≤1)。 

请你帮zzz算出整个电路断路的概率。 

元件的连接方式很简单，对电路的表示： 

1.      一个元件是最小的电路，用A表示元件1，B表示元件2，如此类推。 

2.      k个电路组成的串联电路表示为：电路1，电路2，...，电路k。 

k个电路组成的并联电路表示为：(电路1)(电路2)...(电路k)。

Input

第一行是一个整数n(1≤n≤26)，表示一共有多少个元件；第二行是表示电路的字符串；最后是n行，每行是一个实数Pi(i=1，...n，0≤Pi≤1)，表示该元件断路的概率。

Output

输出一个实数，表示整个电路断路的概率，精确到小数点后4位。

Sample Input

5(A,B)((C)(D),E)0.20.30.40.50.6

Sample Output

0.2992

Problem Source

ZSUACM Team Member

// Problem#: 1139
// Submission#: 3274353
// The source code is licensed under Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
// URI: http://creativecommons.org/licenses/by-nc-sa/3.0/
// All Copyright reserved by Informatic Lab of Sun Yat-sen University
#include <stdio.h>
#include <iostream>
#include <vector>
#include <string>
#include <stack>
#include <iomanip>
using namespace std;

#ifndef _CALCULATOR_H
#define _CALCULATOR_H

class Calculator {
  public:
    string trans_to_postfix_expression_to_s(string);  // 将得到的表达式转化为后缀表达式
    double calculate_from_postfix_expression();  // 根据后缀表达式计算值
    bool bracket_check(string);  // 检查括号匹配与否
    bool operator_check(string);  // 检查是否有不合法操作符
  private:
    vector<string> ans_vector_post;  // 存放后缀表达式
    string post_string;  // 存放后缀表达式
};

inline int prior(char op) {  // 计算优先级函数
    if (op == '+' || op == '-') {
        return 1;
    } else if (op == '*' || op == '/' || op == '%') {
        return 2;
    } else {
        return 0;
    }
}

double string_to_double(string in) {  // 将输入的字符串转化为相应数字函数
    char s[50];
    for (int i = 0; i < 50; i++) {
        s[i] = '\0';
    }
    for (int i = 0; i < in.size(); i++) {
        s[i] = in[i];
    }
    double ans;
    sscanf(s, "%lf", &ans);
    return ans;
}

string erase_blank(string s) {  // 去除空格函数
    for (int i = 0; i < s.size();) {
        if (s[i] == ' ') s.erase(i, 1);
        else i++;
    }
    return s;
}

string dealWithNegative(string s) {  // 负数的预处理，将"-("转化成"-1*("，比如"-(-1)"->"-1*(-1)"
    for (int i = 0; i < s.size() - 1; i++) {
        if (s[i] == '-' && s[i + 1] == '(') s.insert(i + 1, "1*");
    }
    return s;
}

bool Calculator::bracket_check(string in) {
    stack<char> st_bracket;
    for (int i = 0; i < in.size(); i++) {
        if (in[i] == '(' || in[i] == ')') {
            if (st_bracket.empty()) {
                st_bracket.push(in[i]);
            } else {
                if (st_bracket.top() == '(' && in[i] == ')') {
                    st_bracket.pop();
                } else {
                    st_bracket.push(in[i]);
                }
            }
        }
    }
    if (st_bracket.empty()) {
        return 1;
    } else {
        return 0;
    }
}

inline bool isLegal(char c) {  // 判断一个操作符是否合法
    return ('0' <= c && c <= '9') || c == '.' || c == '+' || c =='-' || c == '*' || c == '/' || c == '(' || c == ')' || c == ' '; 
}

inline bool isOperator(char c) {
    return c == '.' || c == '+' || c =='-' || c == '*' || c == '/';
}

bool Calculator::operator_check(string in) {  // 检查是否有不合法操作符

    for (int i = 0; i < in.size(); i++) {
        if (!isLegal(in[i])) return false;  // 出现除0123456789.+-*/() 以外的字符
        if (i > 0 && isOperator(in[i]) && isOperator(in[i - 1])) return false;  // ".+-*/相邻"
        if (i > 0 && in[i] == '(' && in[i - 1] == ')') return false;  // 出现")("
    }
    return true;
}

string Calculator::trans_to_postfix_expression_to_s(string in) {
    
    stack<char> op;  // 操作符栈
    ans_vector_post.clear();  // 后缀表达式存放数组
    bool nextIsNega = false;  // 判断负数
    for (int i = 0; i < in.size();) {
        char c = in[i];
        if ((i > 0 && (in[i - 1] == '+' || in[i - 1] == '-' || in[i - 1] == '*' || in[i - 1] == '/' || in[i - 1] == '(') && in[i] == '-') || (i == 0 && in[i] == '-')) {  // 判断是否为负数
            nextIsNega = true;
            i++;
            continue;
        }
        if (('0' <= c && c <= '9') || c == '.') {  // 是数字直接插入
            string num;
            int j;
            for (j = i; j < in.size() && (('0' <= in[j] && in[j] <= '9') || in[j] == '.'); j++) {
                num.push_back(in[j]);
            }
            if (nextIsNega) {
                num = "-" + num;
                nextIsNega = false;
            }
            ans_vector_post.push_back(num);
            i = j;
        } else {
            if (c == '(') {  // 是开括号直接插入
                op.push('(');
            } else {
                if (c == ')') {  // 是闭括号就把原本栈中的运算符都输出，直到遇到开括号，注意开括号要丢弃
                    while (op.top() != '(') {
                        string temp;
                        temp.push_back(op.top());
                        ans_vector_post.push_back(temp);
                        op.pop();
                    }
                    op.pop();
                } else {  // 假如是加减乘除取余
                    if (op.empty()) {  // 操作符栈是空就直接插入
                        op.push(c);
                    } else {  // 如果扫描到的运算符优先级高于栈顶运算符则，把运算符压入栈。否则的话，就依次把栈中运算符弹出加到数组ans的末尾，直到遇到优先级低于扫描到的运算符或栈空，并且把扫描到的运算符压入栈中
                        if (prior(c) > prior(op.top())) {
                            op.push(c);
                        } else {
                            while (!op.empty() && prior(c) <= prior(op.top())) {
                                string temp;
                                temp.push_back(op.top());
                                ans_vector_post.push_back(temp);
                                op.pop();
                            }
                            op.push(c);
                        }
                    }
                }
            }
            i++;
        }
    }
    while (!op.empty()) {  // 注意把操作符栈中的剩余操作符输出
        string temp;
        temp.push_back(op.top());
        ans_vector_post.push_back(temp);
        op.pop();
    }
    
    post_string.clear();  // 构造string并返回
    for (int i = 0; i < ans_vector_post.size(); i++) {
        post_string += ans_vector_post[i];
    }
    
    return post_string;
}

double Calculator::calculate_from_postfix_expression() {
    
    //利用栈对后缀表达式求值，直接从后缀表达式的左往右扫描，遇到数字放入栈中，遇到字符就把栈顶的两个数字拿出来算，然后再放进栈
    
    stack<double> ans_post;
    for (int i = 0; i < ans_vector_post.size(); i++) {
        double x, y;
        if (('0' <= ans_vector_post[i][0] && ans_vector_post[i][0] <= '9') || (ans_vector_post[i][0] == '-' && '0' <= ans_vector_post[i][1] && ans_vector_post[i][1] <= '9')) {
            ans_post.push(string_to_double(ans_vector_post[i]));
        } else {
            y = ans_post.top();  // 注意顺序，这里好比xy+就是x+y
            ans_post.pop();
            x = ans_post.top();
            ans_post.pop();
            if (ans_vector_post[i][0] == '+') {  // 改变加法的意义
                ans_post.push(1.0 - (x * (1 - y) + (1 - x) * y + (1 - x) * (1 - y)));
            } else if (ans_vector_post[i][0] == '-') {
                ans_post.push(x - y);
            } else if (ans_vector_post[i][0] == '*') {
                ans_post.push(1.0 - ((1 - x) * (1 - y)));
            } else if (ans_vector_post[i][0] == '/') {
                ans_post.push(x / y);
            }
        }
    }
    return ans_post.top();
}

#endif

int main() {

    std::ios::sync_with_stdio(false);

    int N;
    string p[30];
    string expression;
    cin >> N >> expression;
    for (int i = 0; i < N; i++) {
        cin >> p[i];
    }

    for (int i = 0; i < expression.size(); i++) {
        if (expression[i] == ',') {
            expression[i] = '*';
        }
    }

    for (int i = 0; i < expression.size() - 1; i++) {

        if (expression[i] == ')' && expression[i + 1] == '(') {
            expression.insert(i + 1, "+");
            int counter = 0;
            for (int j = i - 1; j >= 0; j--) {
                if (expression[j] == '(' && counter == 0) {
                    expression.insert(j, "(");
                    break;
                } else if (expression[j] == ')') {
                    counter--;
                } else if (expression[j] == '(') {
                    counter++;
                }
            }
            counter = 0;
            for (int j = i + 4; j < expression.size(); j++) {
                if (expression[j] == ')' && counter == 0) {
                    expression.insert(j + 1, ")");
                    break;
                } else if (expression[j] == '(') {
                    counter--;
                } else if (expression[j] == ')') {
                    counter++;
                }
            }
        }

    }

    for (int i = 0; i < expression.size(); i++) {
        if ('A' <= expression[i] && expression[i] <= 'Z') {
            int pos = expression[i] - 'A';
            expression.erase(i, 1);
            expression.insert(i, p[pos]);
        }
    }

    Calculator c;
    c.trans_to_postfix_expression_to_s(expression);
    cout << setprecision(4) << std::fixed << c.calculate_from_postfix_expression() << endl;

    return 0;
}