编程问题 - 积木游戏

Question

也许您对如何解决以下problem 有一个想法。

约翰决定给儿子约翰尼买一些数学玩具。他最喜欢的玩具之一是不同颜色的积木。约翰决定购买不同颜色的 C 块。对于每种颜色，他都会购买 googol (10^100) 块。所有相同颜色的块具有相同的长度。但是不同颜色的块的长度可能会有所不同。 Jhonny 决定使用这些积木制作一个 1 x n 的大积木。他想知道有多少种方法可以做到这一点。如果存在颜色不同的位置，则认为两种方式不同。该示例显示了一个大小为 5 的红色块、大小为 3 的蓝色块和大小为 3 的绿色块。它表明有 12 种方法可以制作一个长度为 11 的大块。

每个测试用例都以整数 1 ≤ C ≤ 100 开始。下一行包含 c 个整数。第 i 个整数 1 ≤ leni ≤ 750 表示第 i 个颜色的长度。下一行是正整数 N ≤ 10^15。

对于 T MOD 100000007（质数）。

可以推导出为矩阵求幂问题，使用Coppersmith-Winograd算法和快速求幂可以在O(N^2.376*log(max(leni)))中相对高效地解决。但似乎需要一种更有效的算法，因为 Coppersmith-Winograd 意味着一个很大的常数因子。你还有其他建议吗？它可能是数论或分治问题

Answer 1

首先注意你拥有的每种颜色的块数是一个完整的红鲱鱼，因为 10^100 > N 总是。所以每种颜色的块数实际上是无限的。

现在请注意，在每个位置，p（如果有有效的配置，则不留空格等）必须有一个颜色块，c。这个块有len[c] 的方式可以撒谎，所以它仍然在这个位置上，p。

我的想法是在固定位置尝试所有可能的颜色和位置（N/2，因为它将范围减半），然后对于每种情况，在此固定颜色块之前有 b 单元格，之后有 a这个固定色块。因此，如果我们定义一个函数ways(i)，它返回平铺i 单元格的方法数（使用ways(0)=1）。那么在某个位置用固定色块平铺多个单元格的方法数为ways(b)*ways(a)。将所有可能的配置相加得出ways(i) 的答案。

现在我选择了固定位置为N/2，因为它将范围减半，您最多可以将范围减半ceil(log(N)) 次。现在，由于您要移动一个关于N/2 的块，您必须从N/2-750 计算到N/2-750，其中750 是一个块可以具有的最大长度。因此，您必须计算大约 750*ceil(log(N))（由于方差而更多）长度才能得到最终答案。

因此，为了获得良好的性能，您必须完成记忆，因为这本质上是一种递归算法。

所以用Python（因为我很懒，不想写大数的类）：

T = int(raw_input())

for case in xrange(T):
    #read in the data
    C = int(raw_input())
    lengths = map(int, raw_input().split())
    minlength = min(lengths)
    n = int(raw_input())

    #setup memoisation, note all lengths less than the minimum length are
    #set to 0 as the algorithm needs this
    memoise = {}
    memoise[0] = 1
    for length in xrange(1, minlength):
       memoise[length] = 0

    def solve(n):
        global memoise
        if n in memoise:
            return memoise[n]

        ans = 0
        for i in xrange(C):
            if lengths[i] > n:
                continue
            if lengths[i] == n:
                ans += 1
                ans %= 100000007
                continue 
            for j in xrange(0, lengths[i]):
                b = n/2-lengths[i]+j
                a = n-(n/2+j)
                if b < 0 or a < 0:
                    continue
                ans += solve(b)*solve(a)
                ans %= 100000007
        memoise[n] = ans
        return memoise[n]
    solve(n)
    print "Case %d: %d" % (case+1, memoise[n])

请注意，我没有对此进行详尽的测试，但如果您将此算法翻译成 C++ 或类似的语言，我很确定它会满足 20 秒的时间限制。

编辑：使用N = 10^15 和长度为750 的块运行测试我知道memoise 包含大约60000 元素，这意味着solve(n) 的非查找位被调用的次数大致相同.

Answer 2

请注意：在 c=2, len1=1, len2=2 的情况下，答案将是第 N 个斐波那契数，并且斐波那契数（大约）以黄金的增长因子呈指数增长比率，phi ~ 1.61803399。为了 巨大的值 N=10^15，答案将是大约 phi^(10^15)，一个巨大的数字。答案将有存储 (ln(phi^(10^15))/ln(2)) / (8 * 2^40) ~ 79 TB 的要求。因为你甚至不能访问 79 TB 在 20 秒内，您不太可能满足这种特殊情况下的速度要求。

当 C 不太大并且 leni 对所有 i 都很大时，你的最大希望就出现了。在这种情况下，答案将 仍然随着 N 呈指数增长，但增长因子可能要小得多。

我建议您首先构造整数矩阵 M 来计算 (i+1,..., i+k) 基于 (i, ..., i+k-1) 项的序列中的项。 （只有这个矩阵的第 k+1 行是有趣的）。 “手动”计算前 k 个条目，然后根据重复平方计算 M^(10^15) 技巧，并将其应用于术语（0...k-1）。

矩阵的（整数）条目将呈指数增长，可能太快而无法处理。如果是这种情况，请执行 对于几个中等大小的素数 p，计算完全相同，但取模 p。这将允许您获得 对于各种 p，您的答案以 p 为模，而不使用 bigints 矩阵。使用足够的素数后，您可以了解他们的产品 大于你的答案，你可以用所谓的“中国剩余定理”来恢复 你从你的 mod-p 答案中得到的答案。

Answer 3

我想在早期的@JPvdMerwe 解决方案的基础上进行一些改进。在他的回答中，@JPvdMerwe 使用了动态编程/记忆方法，我同意这是解决这个问题的方法。将问题递归地划分为两个较小的问题并记住先前计算的结果是非常有效的。

我想提出一些可以进一步加快速度的改进：

1. 不需要遍历所有可以定位中间块的方式，只需遍历前半部分，然后将解乘以 2。这是因为后半部分的情况是对称的.对于奇数长度的块，您仍然需要将居中位置作为单独的情况。

2. 一般来说，迭代实现可以比递归实现快几个数量级。这是因为递归实现会为每个函数调用带来记账开销。将解决方案转换为其迭代表亲可能是一个挑战，但通常是可能的。 @JPvdMerwe 解决方案可以通过使用堆栈来存储中间值进行迭代。

3. 模运算成本高昂，乘法运算成本较低。通过将颜色循环与位置循环进行切换，乘法和模数的数量可以减少大约 C=100 倍。这允许您在进行乘法和取模之前将多个调用的返回值添加到solve()。

测试解决方案性能的一个好方法是使用病态案例。以下内容可能特别令人生畏：长度 10^15、C=100、素数块大小。

希望这会有所帮助。

Answer 4

在上面的回答中

    ans += 1
    ans %= 100000007

如果没有一般的模数可能会快得多：

    ans += 1
    if ans == 100000007 then ans = 0

Answer 5

请参阅TopCoder thread 以获得解决方案。没有人足够接近在此线程中找到答案。