与乐高塑料积木 C++ 的组合数量

Question

您有一些乐高塑料积木，所有积木都是 1x1x1。此外，您还有一块 1xN (N

这是一个例子：

如果图块是 1x7，则有 17 种不同的组合。

输入：7 输出：17

_{（来源：mendo.mk）}

此外，如果您没有积木，则算作 1 个组合。

我已经解决了这个问题，并且我找到了计算图块的最大长度是否为 14（3 个序列）的可能组合的方法。我发现它使用 for 循环。

我最大的问题是我需要运行大量的 for 循环。例如，对于 1 个序列，我使用 1 个 for 循环，对于 2 个序列，2 个循环 + 1 个用于 1 个序列......所以如果我使用所有 80 个砖块，我可以创建 20 个序列，我将不得不使用超过 210 个 for 循环，即数量巨大。因此，如果我可以将它们嵌套在一个中，那就太好了。我试过了，结果很乱，而且没有给出正确的答案。

新代码：

#include <iostream>
using namespace std;
int main()
{
    long long int places, combinations = 1;
    cin >> places;
    long long int f[80], g[80];
    f[0] = 0;
    f[1] = 0;
    f[2] = 0;
    g[0] = 1;
    g[1] = 1;
    g[2] = 1;
    for(int i = 3; i<=places; i++)
    {
        f[i] = f[i-1] + g[i-3];
        g[i] = f[i-1] + g[i-1];
    }
    combinations = f[places] + g[places];
    cout << combinations;
    return 0;
}

Answer 1

如果这是一个计数问题（不输出组合，而只是计数它们），那很容易。假设我们现在求解 n ≥ 3 以求解 n+1，我们通过归纳求解：

假设f 是一个函数，它显示最后一项是砖块的可能方式的数量。 类似地，g 是一个函数，它显示最后一项不是砖块的可能方式的数量。 让h = f+g 定义为所有可能方式的数量。

所以我们有：

f(n+1) = f(n) + g(n-2)
g(n+1) = g(n) + f(n)

有初始条件：

for n=0,1,2: g=1, f= 0.
for n = 3: g=1,f=1

样品：

n=4: g=2,f=2 ==> h=4
n=5: g=4, f= 3 ==> h=7
n=6: g=7, f= 4 ==> h=11
n=7: g=11,f=6 ==> h=17

我们可以在O(n) 中用一个for循环来解决它。

---

为什么：

f(n+1) = f(n) + g(n-2)
g(n+1) = g(n) + f(n)

首先，证明第一部分：

请记住，我们假设 f(n) 是在最后一项中有塑料砖的有效解决方案，而 g(n) 是在最后一项中没有砖的有效解决方案。

f(n+1) 可以从 f(n) 获得，方法是在最后一个位置添加一块砖。 f(n+1)也可以通过在g(n-2)后面加上三个brick得到，即n-1,n,n+1个单元格。

请注意，我们不能在 g(n-1) 或 g(n) 之后添加砖块来创建 f(n+1) 的有效解决方案，因为它们不是有效解决方案（连续砖块的数量小于 3 ）。另外，请注意，我们不需要计算通过在 g(n-3) 之后添加砖块而出现的方式数量，因为它们之前已由 f(n) 枚举。所以我们有f(n+1) = f(n) + g(n-2)。

以同样的方式我们可以证明g(n+1) = f(n)+g(n) 这种情况更容易，因为 g(n+1) 可以简单地由直到n 的任何有效解组成，因为这里没有 3 个连续的砖障碍，它们可以在任何有效解决方案之后。

Answer 2

作为一个受过数学训练而不是 CS 的人，我觉得有必要提一下，虽然 Saeed Amiri 的算法非常好，并且可能足够快地处理 N 到几百万（当然，具有恒定内存），从时间的角度来看，有更好的算法。

我会在他离开的地方接他：

f(n+1) = f(n) + g(n-2)
g(n+1) = f(n) + g(n)

由于 f 和 g 是离散函数，您可以将它们视为序列。于是，这变成了一个递推关系的线性系统。幸运的是，这样的系统可以完全解决，从而可以呈现 f 和 g 的显式形式。
不幸的是，SO 似乎不像 math.SE 那样支持 MathJax，所以我为从这里开始的低质量方程道歉。
让

 | f(n) |
     |f(n-1)|
u(n)=|f(n-2)|
     | g(n) |
     |g(n-1)|
     |g(n-2)|

即u(n)是一个向量行。那么，以下是正确的：

|f(n+1)| |1 0 0 0 0 1| | f(n) | | f(n) | |1 0 0 0 0 0| |f(n-1)| |f(n-1)| = |0 1 0 0 0 0| . |f(n-2)| |g(n+1)| |1 0 0 1 0 0| | g(n) | | g(n) | |0 0 0 1 0 0| |g(n-1)| |g(n-1)| |0 0 0 0 1 0| |g(n-2)|

由此而来的是u(n) = A * u(n-1)，其中 A 是上面的矩阵。
然后，u(n) = (A^(n-2)) * u(2)，其中u(2) 是向量，包含问题的初始值。这反过来又给出了一个具有O(log(n)) 复杂度的算法，因为您可以使用快速求幂来计算(A^(n-2))，然后将其乘以u(2)。

当然，任何这样的技术都可能需要某种 BigInt，否则几乎可以保证溢出。

另请注意，这项技术可以进一步应用：
你可以找到A的特征向量和特征值，然后将u(2)分解成特征向量。然后，您将获得 f(n) 和 g(n) 的封闭形式。

我强烈建议您不要使用基于封闭形式的算法
它几乎肯定会涉及高精度浮点计算（除非所有特征值都是整数，这是极不可能的），从编程的角度来看，这至少具有这种复杂性，并且通常不是恒定时间操作。当然，BigInt 操作也不是。所以恒定时间算法通常是不可行的，而且你可能甚至不需要O(log(n))，因为对于大多数用途来说，线性就足够了。

注意
这里描述的技术可以用于各种问题，并且在动态优化问题中非常有用。另外，通常人们在第一次看到这个时会印象深刻；）