相关疑难解决方法(0)

我有一个关于多项式时间算法,非多项式时间算法和指数时间算法之间差异的问题,例如,如果一个算法需要O(n ^ 2)时间,那么它将属于哪个类别？

我正常的搜索foo让我失望.我正在尝试找到一个R函数,它返回整数的所有因子.至少有2个包含factorize()函数的包:gmp和conf.design,但这些函数只返回素因子.我想要一个能够返回所有因子的函数.

显然,搜索这个很困难,因为R有一个叫做因子的结构,它会在搜索中产生很多噪音.

我已经编写了这段代码,但它耗费了大量的时间来计算......你能帮我找到一个有效的方法吗？

int tag;
int* factors(int n)
{
    int a[1000000];
    for(int i=1;i<=n/2;i++)
        if(n%i==0)
            a[++tag]=i;
    a[++tag]=n;
    return(a);
}

这种蛮力方法在复杂性方面非常沉重......对于这个问题,有没有更好的可行解决方案？

我正在寻找采用由位组成的加权经典状态之和组成的任意量子状态的算法,如下所示:

|0000>/2 - |0011>/2 + |0100>/2 - |0111>/2

并使用张量产品将其分解为更紧凑的形式,如下所示:

|0> x (|0> + |1>) x (|00> - |11>) / 2

我想使用该算法作为一种可视化/简化(模拟)量子电路状态的方法.

对于单个量子位,我知道我可以将所有状态与位被翻转的状态配对,并检查每对状态之间是否具有相同的x:y关系.在上面的例子中,翻转第二位总是给你一个加权为1:1的状态,所以第二位因子为(1 | 0> + 1 | 1>).

但扩展这种方法来检测纠缠位(如示例中的第三和第四位)导致它至少?(n^c)花费时间(可能更多,我没有想到它一直通过),n状态的数量在哪里,c是纠缠位数.因为n已经以指数的方式呈指数级增长......不理想.

有更好的算法吗？表示更容易从/到？改变基础有用吗？论文的链接会很棒.

我正在尝试编写一个程序,以找到一个非常大的最大素数因子,并尝试了几种不同的成功方法.到目前为止我发现的所有这些都令人难以置信地缓慢.我有一个想法,我想知道这是否是一个有效的方法:

long number = input;

while(notPrime(number))
{
    number = number / getLowestDivisiblePrimeNumber();
}

return number;

这种方法需要输入,并将执行以下操作:

200 - > 100 - > 50 - > 25 - > 5(返回)

90 - > 45 - > 15 - > 5(返回)

它将currentNum重复除以最小的可分数(最常见的是2或3),直到currentNum本身为素数(没有可分的素数小于currentNum的平方根),并假设这是原始输入的最大素数因子.

这会一直有效吗？如果没有,有人可以给我一个反例吗？

-

编辑:非常大,我的意思是大约2 ^ 40,或10 ^ 11.

实际上,给定N a(可能非常大)偶数,我想找到N = F*R,其中gcd(F,R)= 1,F> R,F尽可能小(因为我将完全保理F).问题的核心是找到最大的除数R,其中R <sqrt(N).

例如,N = 36应该给出F = 9和R = 4.请注意,R不一定是素数,也不是素数.请注意,我不考虑N.对F和R的唯一限制是它们是相对素数.

这是我的快速和天真的版本,它正在工作:

def factor_partial(N):
    for R in xrange(int(math.sqrt(N)),1,-1):
        if N%R == 0 and gcd(R,N/R) == 1:
            return N/R, R

我想象的另一种方法是按顺序查找除数,并沿途移除任意多个非除数.就像是:

def factor_partial(N):
    i = range(2, int(sqrt(N)) + 1)
    while i:
        if N % i[0] != 0:
            remove_multiples(i, i[0]) #without removing i[0]
        else:
            if gcd(i[0], N/i[0]) == 1:
                R = i[0]
        i.pop(0) #remove i[0]

    return N/R, R

我认为这将是缓慢和内存密集的,但也许如果i是生成器它可能是有效的.我没有太多使用发电机.

我可以改进第一个版本吗？第二个版本是否可行(我将如何做)？有一种完全不同的方法更好吗？

在python,c或pseudocode中寻找答案.

这是一个关于数论的课程.我正在实施基于Pocklington的素性测试.虽然我需要一个分解算法,但我们还没有研究过任何一个,我可能不会使用像我的班级范围之外的二次筛子.我正在寻找提出问题的具体帮助.

我正在寻找一种算法,将一个给定的数字表示为(最多)四个方格的总和.

例子

       120 = 8 ² + 6 ² + 4 ² + 2 ²
       6 = 0 ² + 1 ² + 1 ² + 2 ²
       20 = 4 ² + 2 ² + 0 ² + 0 ²

我的方法

取平方根并重复重复此余数:

while (count != 4) {
    root = (int) Math.sqrt(N)
    N -= root * root
    count++
} 

但是当N为23时,即使有解决方案,这也会失败:

       3 ² + 3 ² + 2 ² + 1 ²

题

1. 有没有其他算法可以做到这一点？

2. 它总是可能吗？

给出一个整数列表(最多1000个)乘以给定的整数n.

我需要在整数的所有除数中找到最高的幂n.

例如:4,7,8乘以224,最高功率则为5,因为224 = 2 ^ 2*7*2 ^ 3 = 2 ^ 5*7.

问题是,1000个整数可以大到2 ^ 64,因此n非常大.

什么是一个很好的算法来解决这个问题？