Boolean Evaluation Java 走地牙 CTCI 8.14

Boolean Evaluation: Given a boolean expression consisting of the symbols 0 (false), 1 (true), & (AND), I (OR), and /\ (XOR), and a desired boolean result value result, implement a function to count the number of ways of parenthesizing the expression such that it evaluates to result. The expressionshouldbefullyparenthesized(e.g.,(0)A(1))butnotextraneously(e.g.,(((0))/\(1))).

EXAMPLE

countEval("l/\01011", false) -> 2 countEval("0&0&0&1All0", true)-> 10

/*
思路：动态规划；
建立两个二维数组T[i][j], F[i][j] 分别表示char数组第i到第j之间结果分别为真或者假的个数；
设k为操作符的指针，T与F的值一定与k位置和k位置的操作符有关；
[i][k] 表示的是i --- j的区间中 k 符号位置的前半段
[k + 1][j] 后半段
表达式： k = &时： T[i][j] += T[i][k] * T[k + 1][j];
                   F[I][J] += T[i][k] * F[k + 1][j] + F[i][k] * T[k + 1][j] + F[i][k] * F[k + 1][j];
         k = |时： T[i][j] += T[i][k] * F[k + 1][j] + F[i][k] * T[k + 1][j] +                 T[i][k] * T[k + 1][j];
                   F[i][j] += F[i][k] * F[k + 1][j];
         k = ^时： T[i][j] += T[i][k] * F[k + 1][j] + F[i][k] * T[k + 1][j];
                   F[i][j] += T[i][k] * T[k + 1][j] + F[i][k] * F[k + 1][j];
+= 的目的是为了把k层次的循环都写入T和F的结果中
*/
public class Solution {
    /**
     * @param symb: the array of symbols
     * @param oper: the array of operators
     * @return: the number of ways
     */
    public int countParenth(char[] symb, char[] oper) {
        // write your code here
        int[][] T = new int[symb.length][symb.length];
        int[][] F = new int[symb.length][symb.length];
        for(int i = 0; i < symb.length; i++) {
            T[i][i] = symb[i] == 'T' ? 1 : 0;
            F[i][i] = symb[i] == 'F' ? 1 : 0;
        }
        for(int j = 0; j < symb.length; j++) {
            for(int i = j - 1; i >= 0; i--) {
                for(int k = i; k < j; k++) {
                    switch(oper[k]) {
                        //+= 的目的是为了把k层次的循环都写入T和F的结果中
                        case '&' :
                            T[i][j] += T[i][k] * T[k + 1][j];
                            F[i][j] += T[i][k] * F[k + 1][j] + F[i][k] * T[k + 1][j] + F[i][k] * F[k + 1][j];
                            break;
                        case '|' :
                            T[i][j] += T[i][k] * F[k + 1][j] + F[i][k] * T[k + 1][j] + T[i][k] * T[k + 1][j];
                            F[i][j] += F[i][k] * F[k + 1][j];
                            break;
                        case '^' :
                            T[i][j] += T[i][k] * F[k + 1][j] + F[i][k] * T[k + 1][j];
                            F[i][j] += T[i][k] * T[k + 1][j] + F[i][k] * F[k + 1][j];
                            break;
                    }
                }
            }
        }
        return T[0][symb.length - 1];
    }
}