Question

在我的项目中，问题的一部分存在。但为了简化，这里的问题正在制定中。有两个正的共素整数：a和b，其中a < b。列出了从{1}到a的{{1}}的倍数，然后是b-1的模数运算。

b，a mod b，2*a mod b，...，3*a mod b

现在，还有另一个整数，比如(b-1)*a mod b。通过列表中的第一个n ( 1 <= n < b)数字，我们必须找到有多少数字，比如n（m）。这可以用蛮力方法完成，从而得到1 <= m < b。

一个例子：

O(n)

列表是：

a=6, b=13, n=8, m=6

这是从1到12的数字的排列，因为如果我们包含另一个数字，即6, 12, 5, 11, 4, 10, 3, 9, 2, 8, 1, 7，任何两个共素的模运算都会产生数字的排列。如果我们选择0，则列表将为a= 2, b=13，这会给出一种模式。如果2, 4, 6, 8, 10, 12, 1, 3, 5, 7, 9, 11和a非常大（在我的项目中它们可以达到10 ^ 20），那么我不知道如何推断出如此大数字的模式。

现在回到示例，我们从列表中取出第一个b数字，这样就可以了解

n = 8

将6, 12, 5, 11, 4, 10, 3, 9运算符应用于less-than，它会将小于m = 6的数字的总数设为3，如下面的列表中所述

m

其中0表示不小于0, 0, 1, 0, 1, 0, 1, 0，1表示小于m。

因为，上面的算法是m，这对于O(n)的范围是不可接受的，所以社区可以给出提示/线索/提示以使我达到{{1}解决方案，甚至是更好的[0, 10^20]解决方案？

Answer 1

（警告：我对于不是[0，n]的乘数范围有点不满，所以我调整了它。这很容易补偿。）

我将使用经过测试的Python代码绘制草图，该实现可以及时运行 O（log max {a，b}）。首先，这里有一些实用功能和一个天真的实现。

from fractions import gcd
from random import randrange


def coprime(a, b):
    return gcd(a, b) == 1


def floordiv(a, b):
    return a // b


def ceildiv(a, b):
    return floordiv(a + b - 1, b)


def count1(a, b, n, m):
    assert 1 <= a < b
    assert coprime(a, b)
    assert 0 <= n < b + 1
    assert 0 <= m < b + 1
    return sum(k * a % b < m for k in range(n))

现在，我们怎样才能加快速度呢？第一个改进是将乘数划分为不相交的范围，使得在一个范围内，a的相应倍数在b的两个倍数之间。知道了最低值和最高值，我们可以通过天花板分数计算小于m的倍数。

def count2(a, b, n, m):
    assert 1 <= a < b
    assert coprime(a, b)
    assert 0 <= n < b + 1
    assert 0 <= m < b + 1
    count = 0
    first = 0
    while 0 < n:
        count += min(ceildiv(m - first, a), n)
        k = ceildiv(b - first, a)
        n -= k
        first = first + k * a - b
    return count

这还不够快。第二个改进是用递归调用替换大多数while循环。在下面的代码中，j是在存在环绕的意义上“完整”的迭代次数。 term3使用类似count2的逻辑来计算剩余的迭代次数。

每个完整的迭代都会在阈值floor(m / a)下提供floor(m / a) + 1或m个残差。我们是否获得+ 1取决于该迭代的first。 first从0开始，并在每次迭代中通过while循环以a - (b % a)模a更改。只要它低于某个阈值，我们就得到+ 1，并且这个计数可以通过递归调用来计算。

def count3(a, b, n, m):
    assert 1 <= a < b
    assert coprime(a, b)
    assert 0 <= n < b + 1
    assert 0 <= m < b + 1
    if 1 == a:
        return min(n, m)
    j = floordiv(n * a, b)
    term1 = j * floordiv(m, a)
    term2 = count3(a - b % a, a, j, m % a)
    last = n * a % b
    first = last % a
    term3 = min(ceildiv(m - first, a), (last - first) // a)
    return term1 + term2 + term3

可以类似于欧几里德GCD算法分析运行时间。

这里有一些测试代码来证明我的正确性声明的证据。请记住在测试性能之前删除断言。

def test(p, f1, f2):
    assert 3 <= p
    for t in range(100):
        while True:
            b = randrange(2, p)
            a = randrange(1, b)
            if coprime(a, b):
                break
        for n in range(b + 1):
            for m in range(b + 1):
                args = (a, b, n, m)
                print(args)
                assert f1(*args) == f2(*args)


if __name__ == '__main__':
    test(25, count1, count2)
    test(25, count1, count3)

共素数模的串行范围的快速算法/公式

1 个答案: