Algorithm 推广算法

我有一个问题：

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)

现在当我有4个

b

的值，即

b（1）

到

b（4）

，那么我将总是有3个

a

的值，即

a（1）

到

a（3）

，我必须计算

beta（1）

到

beta（4）

。因此，要计算的

beta

s的数量取决于

b

的值的数量

---

我无法硬编码，因为需要计算1000个值。如何对其进行概括，即如何以编程方式获取给定

b

、

a

和任意

n

的所有值。 Java代码（请注意，Java从0开始索引，而不是1）：

---

etc

对我来说似乎有效的解决方案是某种形式的记忆递归，以

b

作为向量。这是我的伪代码实现

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

---

你已经概括了：

beta（n）=b（n）-a（1）*beta（n）…a（n-2）*beta（2）-a（n-1）*beta（1）

。。。你现在想要什么？我想他还想把beta（1）、beta（2）等的值放在最后的陈述中。我推广的公式，我不能放在那里，因为每个

beta

，要计算的项数不同。你熟悉循环吗？@greybeard是正确的。如果您需要

BETA（1）

到

BETA（N）

，我的答案很好，但是如果您只需要

BETA（N）

，我的答案是次优的。谢谢您的帮助。：）

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

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