# GeetCode Hub

You are given a valid boolean expression as a string `expression` consisting of the characters `'1'`,`'0'`,`'&'` (bitwise AND operator),`'|'` (bitwise OR operator),`'('`, and `')'`.

• For example, `"()1|1"` and `"(1)&()"` are not valid while `"1"`, `"(((1))|(0))"`, and `"1|(0&(1))"` are valid expressions.

Return the minimum cost to change the final value of the expression.

• For example, if `expression = "1|1|(0&0)&1"`, its value is `1|1|(0&0)&1 = 1|1|0&1 = 1|0&1 = 1&1 = 1`. We want to apply operations so that the new expression evaluates to `0`.

The cost of changing the final value of an expression is the number of operations performed on the expression. The types of operations are described as follows:

• Turn a `'1'` into a `'0'`.
• Turn a `'0'` into a `'1'`.
• Turn a `'&'` into a `'|'`.
• Turn a `'|'` into a `'&'`.

Note: `'&'` does not take precedence over `'|'` in the order of calculation. Evaluate parentheses first, then in left-to-right order.

Example 1:

```Input: expression = "1&(0|1)"
Output: 1
Explanation: We can turn "1&(0|1)" into "1&(0&1)" by changing the '|' to a '&' using 1 operation.
The new expression evaluates to 0.
```

Example 2:

```Input: expression = "(0&0)&(0&0&0)"
Output: 3
Explanation: We can turn "(0&0)&(0&0&0)" into "(0|1)|(0&0&0)" using 3 operations.
The new expression evaluates to 1.
```

Example 3:

```Input: expression = "(0|(1|0&1))"
Output: 1
Explanation: We can turn "(0|(1|0&1))" into "(0|(0|0&1))" using 1 operation.
The new expression evaluates to 0.```

Constraints:

• `1 <= expression.length <= 105`
• `expression` only contains `'1'`,`'0'`,`'&'`,`'|'`,`'('`, and `')'`
• All parentheses are properly matched.
• There will be no empty parentheses (i.e: `"()"` is not a substring of `expression`).

class Solution { public int minOperationsToFlip(String expression) { } }