【Leetcode】224. Basic Calculator

题目地址：

https://leetcode.com/problems/basic-calculator/

给定一个中缀表达式$s$，求其值。表达式中只含非负整数，加减乘除和左右小括号，减号可以作为负号出现。

具体算法参考https://blog.csdn.net/qq_46105170/article/details/106209367。注意这题有负号，我们需要在负号出现的地方前面加个$0$。可以先预处理一下字符串$s$，开另一个字符串$t$来表示最终要处理的表达式。略过空格。判断负号的方式是，如果$t$为空或者$t$结尾是左括号，则说明当前的减号为负号。代码如下：

class Solution {
 public:
  int calculate(string t) {
    string s;
    // 预处理一下t
    for (int i = 0; i < t.size(); i++) {
      if (t[i] == ' ') continue;
      if (t[i] == '-' && (s.empty() || s.back() == '(')) s += '0';
      s += t[i];
    }
    unordered_map<char, int> mp{
        {'(', 0}, {'+', 1}, {'-', 1}, {'*', 2}, {'/', 2}};
    stack<int> stk;
    stack<char> ops;
    for (int i = 0; i < s.size(); i++) {
      if (s[i] == '(') ops.push('(');
      else if (isdigit(s[i])) {
        int x = 0, j = i;
        while (j < s.size() && isdigit(s[j])) x = x * 10 + (s[j++] - '0');
        stk.push(x);
        i = j - 1;
      } else if (s[i] == ')') {
        while (ops.top() != '(') calc(stk, ops);
        ops.pop();
      } else {
        while (ops.size() && mp[ops.top()] >= mp[s[i]]) calc(stk, ops);
        ops.push(s[i]);
      }
    }

    while (ops.size()) calc(stk, ops);
    return stk.top();
  }

  void calc(stack<int>& stk, stack<char>& ops) {
    int b = stk.top(); stk.pop();
    int a = stk.top(); stk.pop();
    char op = ops.top(); ops.pop();
    switch (op) {
      case '+': stk.push(a + b); break;
      case '-': stk.push(a - b); break;
      case '*': stk.push(a * b); break;
      case '/': stk.push(a / b); break;
    }
  }
};

时空复杂度$O(n)$。

我们可以直接通过维护一个状态来做。整数关于加法和乘法形成一个环。初始状态为$(0,1)$（分别是加法单位元和乘法单位元，这个项的含义是$0+1\#$，$\#$的意思是下面的运算符还未定义），接着我们遍历表达式，遍历的时候得到每个项和其前面的运算符。最开始的项的运算符定义为乘法。设当前的状态为$(a,b)$，如果下一项的运算符是乘除法，则说明前面遍历完留的末尾数需要参与乘除运算，例如如果下一项是$x$并且是乘法，则状态变为$(a,b\times x)$，如果是除法则为$(a,b/x)$；如果下一项的运算符是加减法，则说明前面遍历完的项可以合并了，如果是加法，则状态变为$(a+b,x)$，否则变为$(a+b,-x)$。如果遇到括号，则递归求解下一项。最后遍历完之后，将两维相加即得答案。代码如下：

class Solution {
 public:
  int dfs(int &k, string& s) {
    int a = 0, b = 1;
    char op = '*';
    static auto f = [](int &a, int &b, int x, char op) {
      if (op == '+') a += b, b = x;
      else if (op == '-') a += b, b = -x;
      else if (op == '*') b *= x;
      else b /= x;
    };
    while (k < s.size() && s[k] != ')') {
      if (s[k] == ' ') {
        k++;
        continue;
      }
      if (s[k] == '(') {
        int x = dfs(++k, s);
        k++;
        f(a, b, x, op);
      } else if (isdigit(s[k])) {
        int x = 0;
        while (k < s.size() && isdigit(s[k])) 
          x = x * 10 + (s[k++] - '0');
        f(a, b, x, op);
      } else op = s[k++];
    }

    return a + b;
  }

  int calculate(string t) {
    string s;
    for (int i = 0; i < t.size(); i++) {
      if (t[i] == ' ') continue;
      if (t[i] == '-' && (s.empty() || s.back() == '(')) s += '0';
      s += t[i];
    }

    int k = 0;
    return dfs(k, s);
  }
};

时空复杂度一样。