Question

我已经为一个小的本土计算机代数系统写出了一个递归算法，我将成对约简应用于代数运算的操作数列表（仅相邻的操作数，因为代数是非可交换）。我试图了解算法的运行时复杂性（但不幸的是，作为一名物理学家，自从我参加任何处理复杂性分析的本科CS课程以来，这已经很长时间了）。在不详细讨论具体问题的情况下，我认为我可以根据函数f来形式化算法，这是一个＆＃34; divide＆＃34;步骤和结合结果的函数g。然后我的算法将采用以下正式表示形式：

f(1) = 1  # recursion anchor for f
f(n) = g(f(n/2), f(n/2))

g(n, 0) = n, g(0, m) = m            # recursion ...
g(1, 0) = g(0, 1) = 1               # ... anchors for g

           / g(g(n-1, 1), m-1)  if reduction is "non-neutral"
g(n, m) = |  g(n-1, m-1)        if reduction is "neutral"
           \ n + m              if no reduction is possible

在这种表示法中，函数f和g接收列表作为参数和返回列表，输入/输出列表的 length 是参数和右边 - 上面方程式的一面。

有关完整故事，与f和g对应的实际代码如下：

def _match_replace_binary(cls, ops: list) -> list:
    """Reduce list of `ops`"""
    n = len(ops)
    if n <= 1:
        return ops
    ops_left = ops[:n//2]
    ops_right = ops[n//2:]
    return _match_replace_binary_combine(
            cls,
            _match_replace_binary(cls, ops_left),
            _match_replace_binary(cls, ops_right))


def _match_replace_binary_combine(cls, a: list, b: list) -> list:
    """combine two fully reduced lists a, b"""
    if len(a) == 0 or len(b) == 0:
        return a + b
    if len(a) == 1 and len(b) == 1:
        return a + b
    r = _get_binary_replacement(a[-1], b[0], cls._binary_rules)
    if r is None:
        return a + b
    if r == cls.neutral_element:
        return _match_replace_binary_combine(cls, a[:-1], b[1:])
    r = [r, ]
    return _match_replace_binary_combine(
            cls,
            _match_replace_binary_combine(cls, a[:-1], r),
            b[1:])

我对get_binary_replacement的最坏情况感兴趣被调用，取决于ops

的大小

Answer 1

所以我想我现在已经有了。要重述此问题：在使用大小为_get_binary_replacement的输入调用_match_replace_binary时，查找n的来电次数。

定义函数g(n, m)（与原始问题一样），将_match_replace_binary_combine的两个输入的大小映射到输出的大小
定义一个函数T_g(n, m)，它将_match_replace_binary_combine的两个输入的大小映射到获得结果所需的g的调用总数。这也是_get_binary_replacement每次拨打_match_replace_binary_combine最多拨打_get_binary_replacement一次的g来电次数（最差情况）

我们现在可以考虑g(n,m) = n + m的最坏情况和最佳情况：

最佳案例（不减少）：T_g(n, m) = 1，g(n, m) = 1
最差情况（所有非中性减少）：T_g(n, m) = 2*(n+m) - 1，k=1（我凭经验确定）

现在，master theorem (WP)适用：

浏览WP上的描述：

a = 2（递归锚的大小为1）
我们在常量（n/2）时间内分成d = 1大小为c = T_g(n/2, n/2)的子问题
解决子问题后，合并结果所需的工作量为n-1。最差情况为n（约为n * log(n)），最佳情况为1

因此，遵循主页定理的WP页面上的示例，最坏情况复杂度为n，最佳案例复杂度为RewriteCond %{HTTP_HOST} ^(www\.example\.com|example\.com|example2\.example\.com) [NC] RewriteCond %{HTTPS} =on RewriteRule ^/testing$ https://google.co.uk [R=301,L,QSA]

实证试验似乎证实了这一结果。对我的推理线有任何异议吗？

嵌套递归函数的复杂性分析

1 个答案: