在这种情况下如何正确回溯

>问题给定一个由符号0, 1, &, |, ^和所需的布尔结果值组成的布尔表达式，实现一个函数来计算将表达式括起来的方式数，以便其计算结果。
例
表达
1^0|0|1期望的结果
0输出 2, 1^((0|0)|1), 1^(0|(0|1))

我的想法是使用回溯，并评估表单a operator b的表达式。例如

1^0|0|1
------- 0123456

有 3 种可能的评估： 0, 2, 4 ，更具体地说，我有：
(1)评估0 -> 1|0|1
(2)评估0 -> 1|1
(3)评估0 -> 1

然后我在(2)回溯，在位置2进行评估......这个想法很简单，但它产生了重复的结果。result = 1的方法的数量应该3但我的方法产生了4.

bool evaluate(const string& expr) {
    assert(expr.length() == 3);
    assert(expr[0] == '0' || expr[0] == '1');
    assert(expr[1] == '^' || expr[1] == '|' || expr[1] == '&');
    assert(expr[2] == '0' || expr[2] == '1');
    bool result;
    bool a = (expr[0] == '1' ? 1 : 0);
    bool b = (expr[2] == '1' ? 1 : 0);
    switch (expr[1]) {
        case '^' :
            result = a ^ b;
            break;
        case '|' :
            result = a | b;
            break;
        case '&' :
            result = a & b;
            break;
    }
    return result;
}
void transform_at(string& s, int start) {
    bool result = evaluate(s.substr(start, 3));
    string left = s.substr(0, start);
    string right = s.substr(start + 3);
    result ? left.append(1, '1') : left.append(1, '0');
    s = left + right;
}
int count_parenthese_grouping(string expr, const bool result) {
    cout << "[recurse on]: " << expr << endl;
    if (expr.length() == 3 && evaluate(expr) == result) {
        return 1;
    }
    else if (expr.length() == 3 && evaluate(expr) != result) {
        return 0;
    }
    else {
        int operators = expr.length() - 2;
        int total = 0;
        for (int i = 0; i < operators; i += 2) {
            string temp = expr;
            transform_at(expr, i);
            total += count_parenthese_grouping(expr, result);
            expr = temp;
        }
        return total;
    }
}

我看不出这个解决方案是如何产生重复结果的！谁能帮我？