Question

我有这个问题：

beta(1) = b(1);
beta(2) = b(2) - a(1)*beta(1)
beta(3) = b(3) - a(1)*beta(2) - a(2)*beta(1)
beta(4) = b(4) - a(1)*beta(3) - a(2)*beta(2)- a(3)*beta(1)
.
.
.
beta(n) = b(n) - a(1)*beta(n-1)....a(n-2)*beta(2) - a(n-1)*beta(1)

现在当我有b b(1)到b(4)的4个值时，我将始终有a的3个值，即a(1)到{{ 1}}我必须将a(3)计算为beta(1)。因此，要计算的beta(4) s的数量取决于beta的值的数量。

我无法对其进行硬编码，因为要计算1000个值。如何概括它，即如何以编程方式获取给定b，b和仲裁a的所有值？

Answer 1

使用数组并巧妙地运行变量。 Java中的代码（请注意，Java开始使用0开始索引，而不是1）：

for (int i = 0; i < beta.length; i++) {
    beta[i] = b[i];
    for (int j = 0; j < i; j++) {
        beta[i] = beta[i] - a[j]*beta[i-j-1];
    }
}

然后你有

beta[0] == b[0]
beta[1] == b[1] - a[0]*beta[0]
beta[2] == b[2] - a[0]*beta[1] - a[1]*beta[0]

等

Answer 2

对我来说似乎有效的解决方案是使用b作为向量的某种形式的memoized递归。这是我的伪代码实现

MEMO := ALLOCATE(LENGTH(B))
DEFINE BETA(N)
    IF N = 1
        RETURN B[1]
    ELSE IF MEMO[N] != 0
        RETURN MEMO[N]
    ELSE
        MEMO[N] := B[N]

        FOR I IN 1 TO N - 1
            MEMO[N] := MEMO[N] - A[I]*BETA[N-I]
        END FOR

        RETURN MEMO[N]
    END IF
END DEFINE

推广算法

2 个答案: