布尔括号的递归记忆解决方案的运行时复杂度

Question

This是一个经典的算法问题。

DP 解确实是 n^3。

我在下面使用带有记忆的递归。

我需要详细解释一下下面代码的运行时间是什么？我对目前的答案不满意。有人可以帮忙吗？

 public static int countParenthesization(String expr, int begin, int end, boolean result, Map<String, Integer> lookup) {
    String lookupKey = begin + "-" + end + "-" + result;

    if (end - begin == 0) {
        String currenExpr = expr.charAt(begin) + "";
        int count = (currenExpr.equals("T") && result) || (currenExpr.equals("F") && !result) ? 1 : 0;
        lookup.put(lookupKey, count);
        return count;
    }

    if (lookup.containsKey(lookupKey)) {
        return lookup.get(lookupKey);
    }


    int count = 0;
    for (int i = begin + 1; i <= end; i = i + 2) {
        int leftBegin = begin;
        int leftEnd = i - 1;
        int rightBegin = i + 1;
        int rightEnd = end;

        switch (expr.charAt(i)) {
            case '|':
                if (result) {
                    count += countParenthesization(expr, leftBegin, leftEnd, true, lookup)
                            * countParenthesization(expr, rightBegin, rightEnd, true, lookup);
                    count += countParenthesization(expr, leftBegin, leftEnd, true, lookup)
                            * countParenthesization(expr, rightBegin, rightEnd, false, lookup);
                    count += countParenthesization(expr, leftBegin, leftEnd, false, lookup)
                            * countParenthesization(expr, rightBegin, rightEnd, true, lookup);
                } else {
                    count += countParenthesization(expr, leftBegin, leftEnd, false, lookup)
                            * countParenthesization(expr, rightBegin, rightEnd, false, lookup);
                }

                break;
            case '&':
                if (result) {
                    count += countParenthesization(expr, leftBegin, leftEnd, true, lookup)
                            * countParenthesization(expr, rightBegin, rightEnd, true, lookup);
                } else {
                    count += countParenthesization(expr, leftBegin, leftEnd, true, lookup)
                            * countParenthesization(expr, rightBegin, rightEnd, false, lookup);
                    count += countParenthesization(expr, leftBegin, leftEnd, false, lookup)
                            * countParenthesization(expr, rightBegin, rightEnd, true, lookup);
                    count += countParenthesization(expr, leftBegin, leftEnd, false, lookup)
                            * countParenthesization(expr, rightBegin, rightEnd, false, lookup);
                }

                break;
            case '^':
                if (result) {
                    count += countParenthesization(expr, leftBegin, leftEnd, true, lookup)
                            * countParenthesization(expr, rightBegin, rightEnd, false, lookup);
                    count += countParenthesization(expr, leftBegin, leftEnd, false, lookup)
                            * countParenthesization(expr, rightBegin, rightEnd, true, lookup);
                } else {
                    count += countParenthesization(expr, leftBegin, leftEnd, true, lookup)
                            * countParenthesization(expr, rightBegin, rightEnd, true, lookup);
                    count += countParenthesization(expr, leftBegin, leftEnd, false, lookup)
                            * countParenthesization(expr, rightBegin, rightEnd, false, lookup);
                }

                break;
        }
    }

    lookup.put(lookupKey, count);

    //System.out.println(lookup);

    return count;
}

Answer 1

正如所写，您的代码为 O(n^4)。该代码本质上与 DP 解决方案相同，但 DP 解决方案谨慎地使用 O(1) 索引到表中（一对 (i, j) 整数），此代码使用子字符串，构造其中需要 O(n) 时间，在哈希表中查找也需要 O(n) 时间。 [注意：这里的n指的是当前被分片的表达式字符串的长度，而不是哈希表的大小]。

您可以通过使用开始/结束索引并避免字符串切片（和哈希表查找）来弥补增加的复杂性，就像在 DP 解决方案中一样。

具体来说：

• 该函数将采用额外的参数int i, int j 的开始/结束索引而不是预切片表达式。
• 您的 lookup 哈希表的键将更改为元组 <int i, int j, bool result> 而不是字符串。
• 您的代码根本不会执行任何字符串切片。