给定布尔运算式子通过加括号得T/F

• 思路：
• 最小阶段为，（）符号（）。LT,LF,RT,RF之间相乘即可得到最终结果
  • 流程：获取范围L~R，分成两区间各自递归，返回LT,LF,RT,RF的值。根据中间符号的真值表，四个变量组合成需求的T/F

• 代码

  ```JAVA
  	  package class10;
  	  
  	  // 本题测试链接 : https://leetcode-cn.com/problems/boolean-evaluation-lcci/
  	  public class Code05_BooleanEvaluation {
  	  
  	  	public static int countEval0(String express, int desired) {
  	  		if (express == null || express.equals("")) {
  	  			return 0;
  	  		}
  	  		char[] exp = express.toCharArray();
  	  		int N = exp.length;
  	  		Info[][] dp = new Info[N][N];
  	  		Info allInfo = func(exp, 0, exp.length - 1, dp);
  	  		return desired == 1 ? allInfo.t : allInfo.f;
  	  	}
  	  
  	  	public static class Info {
  	  		public int t;
  	  		public int f;
  	  
  	  		public Info(int tr, int fa) {
  	  			t = tr;
  	  			f = fa;
  	  		}
  	  	}
  	  
  	  	// 限制:
  	  	// L...R上，一定有奇数个字符
  	  	// L位置的字符和R位置的字符，非0即1，不能是逻辑符号！
  	  	// 返回str[L...R]这一段，为true的方法数，和false的方法数
  	  	public static Info func(char[] str, int L, int R, Info[][] dp) {
  	  		if (dp[L][R] != null) {
  	  			return dp[L][R];
  	  		}
  	  		int t = 0;
  	  		int f = 0;
  	  		if (L == R) {
  	  			t = str[L] == '1' ? 1 : 0;
  	  			f = str[L] == '0' ? 1 : 0;
  	  		} else { // L..R >=3
  	  			// 每一个种逻辑符号，split枚举的东西
  	  			// 都去试试最后结合
  	  			for (int split = L + 1; split < R; split += 2) {
  	  				Info leftInfo = func(str, L, split - 1, dp);
  	  				Info rightInfo = func(str, split + 1, R, dp);
  	  				int a = leftInfo.t;
  	  				int b = leftInfo.f;
  	  				int c = rightInfo.t;
  	  				int d = rightInfo.f;
  	  				switch (str[split]) {
  	  				case '&':
  	  					t += a * c;
  	  					f += b * c + b * d + a * d;
  	  					break;
  	  				case '|':
  	  					t += a * c + a * d + b * c;
  	  					f += b * d;
  	  					break;
  	  				case '^':
  	  					t += a * d + b * c;
  	  					f += a * c + b * d;
  	  					break;
  	  				}
  	  			}
  	  
  	  		}
  	  		dp[L][R] = new Info(t, f);
  	  		return dp[L][R];
  	  	}
  	  
  	  	public static int countEval1(String express, int desired) {
  	  		if (express == null || express.equals("")) {
  	  			return 0;
  	  		}
  	  		char[] exp = express.toCharArray();
  	  		return f(exp, desired, 0, exp.length - 1);
  	  	}
  	  
  	  	public static int f(char[] str, int desired, int L, int R) {
  	  		if (L == R) {
  	  			if (str[L] == '1') {
  	  				return desired;
  	  			} else {
  	  				return desired ^ 1;
  	  			}
  	  		}
  	  		int res = 0;
  	  		if (desired == 1) {
  	  			for (int i = L + 1; i < R; i += 2) {
  	  				switch (str[i]) {
  	  				case '&':
  	  					res += f(str, 1, L, i - 1) * f(str, 1, i + 1, R);
  	  					break;
  	  				case '|':
  	  					res += f(str, 1, L, i - 1) * f(str, 0, i + 1, R);
  	  					res += f(str, 0, L, i - 1) * f(str, 1, i + 1, R);
  	  					res += f(str, 1, L, i - 1) * f(str, 1, i + 1, R);
  	  					break;
  	  				case '^':
  	  					res += f(str, 1, L, i - 1) * f(str, 0, i + 1, R);
  	  					res += f(str, 0, L, i - 1) * f(str, 1, i + 1, R);
  	  					break;
  	  				}
  	  			}
  	  		} else {
  	  			for (int i = L + 1; i < R; i += 2) {
  	  				switch (str[i]) {
  	  				case '&':
  	  					res += f(str, 0, L, i - 1) * f(str, 1, i + 1, R);
  	  					res += f(str, 1, L, i - 1) * f(str, 0, i + 1, R);
  	  					res += f(str, 0, L, i - 1) * f(str, 0, i + 1, R);
  	  					break;
  	  				case '|':
  	  					res += f(str, 0, L, i - 1) * f(str, 0, i + 1, R);
  	  					break;
  	  				case '^':
  	  					res += f(str, 1, L, i - 1) * f(str, 1, i + 1, R);
  	  					res += f(str, 0, L, i - 1) * f(str, 0, i + 1, R);
  	  					break;
  	  				}
  	  			}
  	  		}
  	  		return res;
  	  	}
  	  
  	  	public static int countEval2(String express, int desired) {
  	  		if (express == null || express.equals("")) {
  	  			return 0;
  	  		}
  	  		char[] exp = express.toCharArray();
  	  		int N = exp.length;
  	  		int[][][] dp = new int[2][N][N];
  	  		dp[0][0][0] = exp[0] == '0' ? 1 : 0;
  	  		dp[1][0][0] = dp[0][0][0] ^ 1;
  	  		for (int i = 2; i < exp.length; i += 2) {
  	  			dp[0][i][i] = exp[i] == '1' ? 0 : 1;
  	  			dp[1][i][i] = exp[i] == '0' ? 0 : 1;
  	  			for (int j = i - 2; j >= 0; j -= 2) {
  	  				for (int k = j; k < i; k += 2) {
  	  					if (exp[k + 1] == '&') {
  	  						dp[1][j][i] += dp[1][j][k] * dp[1][k + 2][i];
  	  						dp[0][j][i] += (dp[0][j][k] + dp[1][j][k]) * dp[0][k + 2][i] + dp[0][j][k] * dp[1][k + 2][i];
  	  					} else if (exp[k + 1] == '|') {
  	  						dp[1][j][i] += (dp[0][j][k] + dp[1][j][k]) * dp[1][k + 2][i] + dp[1][j][k] * dp[0][k + 2][i];
  	  						dp[0][j][i] += dp[0][j][k] * dp[0][k + 2][i];
  	  					} else {
  	  						dp[1][j][i] += dp[0][j][k] * dp[1][k + 2][i] + dp[1][j][k] * dp[0][k + 2][i];
  	  						dp[0][j][i] += dp[0][j][k] * dp[0][k + 2][i] + dp[1][j][k] * dp[1][k + 2][i];
  	  					}
  	  				}
  	  			}
  	  		}
  	  		return dp[desired][0][N - 1];
  	  	}
  	  
  	  }
  	  
  ```