Java 生成一系列表示最小pow（）结果的数字

假设

next（）

是生成此系列的函数：

 8
 9
 16
 25
 27
 32
 36
 49
 64
 81

那是

i=2,3,....
j=2,3,....
f(n) =   minimum( pow(i,j) )   &&   f(n) > f(n-1) 

我可以想出这个O（n）码。有O（1）或O（lg n）解决方案吗

    int m =2, n = 2;
    int last =4;

   void next() {
      int a=m+1,b=n+1;
      long t = pow(a,b);
      int ma = max(m,n);
      //cout<<" max = "<<ma<<endl;
      for(int i=2;i<=ma+1;++i){
         for(int j=2;j<=ma+1;++j){
            if(pow(i,j) > last && pow(i,j) <= t) {
             a=i,b=j;
             t = pow(i,j); 
            }
         }
      } 
      if(a>m) m=a;
      if(b>n) n=b;
      last = t;
      //cout<<"\t"<<a<<"\t"<<b<<"\t"<<pow(a,b)<<endl;
      cout<<" \t"<<pow(a,b)<<endl;
     return;
    }
}

int m=2，n=2；
int last=4；
作废下一页（）{
int a=m+1，b=n+1；
长t=功率（a，b）；
int ma=最大值（m，n）；
//cout（我不知道你是否意识到你的问题是关于完美数系列的）

可能更快的暴力算法：
在给定的范围内生成所有可能的完美能力，并将它们插入到一个排序列表中。但是，我不知道您需要多少重复。肯定需要比您的方法更多的内存，但您没有给出任何限制：）
示例python代码，显然不完美，但确实显示了如何进行惰性迭代。内存使用率为0（提供的物品数量），对于时间，乘以该数量的日志

import heapq

def power_seq(min_b, min_p):
    heap = []
    in_heap_table = {}
    cur_b, cur_p = min_b, min_p 
    heapq.heappush(heap, (power_value(cur_b, cur_p), cur_b, cur_p))
    in_heap_table[power_value(cur_b, cur_p)] = True
    while True:
        power, cur_b, cur_p = heapq.heappop(heap)
        yield power,cur_b, cur_p
        new_b = cur_b + 1
        new_p = cur_p + 1

        if power_value(new_b, cur_p) not in in_heap_table:
            heapq.heappush(heap, (power_value(new_b, cur_p), new_b, cur_p))
            in_heap_table[power_value(new_b, cur_p)] = True

        if power_value(cur_b, new_p) not in in_heap_table:
            heapq.heappush(heap, (power_value(cur_b, new_p), cur_b, new_p))
            in_heap_table[power_value(cur_b, new_p)] = True



# Can be made O(log p) if we want.
def power_value(b,p):
    power = 1
    while p >= 1:
        power = power*b
        p = p-1
    return power



def main():
    count = 0
    for tup in power_seq(2,2):
        print tup
        count += 1
        if count > 30:
            break

if __name__ == "__main__":
    main()

我认为这是一种通过生成器对所有电源结果的排序列表进行惰性构造的方法

想象一个无限的x^y结果场——x在一个方向，y在另一个方向。现在想象一条从2^2（为了简单起见，我们称之为1）开始的路径，一条从东到3^2，一条从西南到2^3，一条从南到2^4，东北两次，一条从东到西南三次，一条从南……等等，呈对角之字形向外移动

当您在所有x^Y上通过此之字形路径时，请将它们添加到自动排序的集合中，该集合总共为O（nlogn）。但是，我们很懒，希望尽快停止

当你被要求获得第n个最大功率时，做Z字形并构建集合，跟踪每个Z字形产生的最小值。如果最小值大于列表中当前第n个位置下方列表中的所有值，我们知道我们永远不会在列表中插入一个会改变结果的较低数字我们会回来的，所以我们会回来的

此外，如果要求您输入第n个最大功率，您可以立即检查最低值是否足够低，以更改该值，如果不足够，则立即返回

此算法是次优的，因为功率在一个方向上的增长速度比在另一个方向上的增长速度快-因此，如果路径偏向于在较慢的增长方向覆盖比较快的增长方向更多的值，则需要搜索较少的值以返回第n个最大功率。
我非常怀疑您是否会找到O（1） solution@B任何小于O（N）的东西都是不可能的，因为输出值是O（N）。也许他对每个值都意味着O（N）。换句话说，O（N^2），而不是O（N ln）或（O（N）。@JamesKanze。这个问题很奇怪，因为代码显示了O（N^2）是的，我认为这是关于生成值的问题，这意味着：f（N）=最小值（pow（i，j））&&f（n）>f（n-1）O（nln（n））的复杂度怎么可能更小因为即使只对向量进行排序也会导致这种复杂性：首先生成值可能比原始算法的复杂性更好这里的主要问题是生成数字，我想另一个问题是原始算法的复杂性是什么。O（n*（logn）^2）可能？（那很好，也很难打败）很好：