Java 当a、b或c<；=1000

我想得到所有毕达哥拉斯四人组：

---

a^2+b^2+c^2=d^2当a，b，c那么，如果您仍然需要存储所有的四倍体，那么这就是新函数，
（感谢达米恩）

只花了1.5秒。用于查找和存储所有85490

   static int findQuadraples(int range)
   {
      int total = 0;

      for (int a = 1; a <= range; a++)
         for (int b = a; b <= range; b++)
            for (int c = b; c <= range; c++)
            {
               int sum = a * a + b * b + c * c;
               int d = isSquare(sum);

               if (d != 0) // a possible Quadruple
               {
                  //System.out.println(Arrays.asList(a, b, c, d));
                  allQuadraples.add(Arrays.asList(a, b, c, d));
                  total++;
               }
            }

      return total;
   }

static int findQuadraples（int范围）
{
int-total=0；
对于（inta=1；a这里有一种不同的方法，使用较慢的语言。这就是将
a^2+b^2
与
d^2-c^2
匹配。操作较慢，但算法是
O（n^2）
而不是
O（n^3）

在Python中，这在我的笔记本电脑上花费了<1.3秒

#! /usr/bin/env python3
limit = 1000

square_differences = {}
for c in range(limit, 0, -1):
    for d in range (c+1, 2*c):
        diff = d*d - c*c
        if 3*limit*limit< diff:
            break
        elif diff not in square_differences:
            square_differences[diff] = []
        square_differences[diff].append((c, d))

quads = []
for a in range(1, limit+1):
    for b in range(a, limit+1):
        s = a*a + b*b
        if s in square_differences:
            for c, d in square_differences[s]:
                if c < b:
                    break
                else:
                    quads.append((a, b, c, d))

print(len(quads))

！/usr/bin/env python3
限额=1000
平方差={}
对于范围内的c（极限，0，-1）：
对于范围（c+1，2*c）内的d：
差异=d*d-c*c
如果3*限制*限制<差异：
打破
elif差异不在平方差异中：
平方差[diff]=[]
平方差[diff]。追加（（c，d））
四边形=[]
对于范围（1，极限+1）内的a：
对于范围（a，极限+1）内的b：
s=a*a+b*b
如果是平方差：
对于c，d的平方差[s]：
如果c
您可以检查此注释，在不改变这种蛮力方法的情况下，您可以通过以下方式获得时间：1.限制对
b>=a
和
c>=b
的搜索；2.对
a*a
和
b*b
1进行因式分解计算。您不希望每次调用sqrt。您可以创建正方形及其根的映射。2。您应该使用以下事实重写您的循环（除了上面提到的假设<代码> A& & B+C> A<代码>我在C++中测试了我的两个建议，在1s左右得到了相同的结果，基本上仍然是蛮力的方法，但不是需要检查的。duplicates@ManojBanik在
b>=a
和
c>=b
的条件下，我避免了所有的重复。我得到了与OP:8590No.:同样也测试了用“代码”>“INTA2= A*A/COD>”等乘法的限制。但是在C++中，增益是可以忽略的。也许在java中测试。你也可以在帖子中提到，主要的优点是避免重复（1）的搜索。你可以改变<代码>新的AARLIST（数组）。（a，b，c，d））
到只
数组。asList（a，b，c，d）
。这是一个不可变的列表，但你无论如何都不会更改；）@vicpermir，是的，它花费的时间更少。更新了我的答案。呜呜，好像我粘贴了
数组.asList（
在我的评论中出现了两次，但是你得到了这样的想法：你的代码会生成所有的四倍吗？因为，在有些情况下，不同的“d^2-c^2”会生成相同的答案，而你并没有通过“diff not in square\u differences”来存储所有答案语句。我在尝试用Java转换您的想法时发现了它。@ManojBanik它生成所有四倍。诀窍是我强制
a最后我能够实现您的
O（n^2）
Java中的
idea
，是的，它比我以前的想法快，因为
1000
需要
0.7秒
。与
2000
的
1.3
相比，需要
3.1秒
。与
3000
的
9.9
相比，需要
10.1秒
。与
33.9
相比。
#! /usr/bin/env python3
limit = 1000

square_differences = {}
for c in range(limit, 0, -1):
    for d in range (c+1, 2*c):
        diff = d*d - c*c
        if 3*limit*limit< diff:
            break
        elif diff not in square_differences:
            square_differences[diff] = []
        square_differences[diff].append((c, d))

quads = []
for a in range(1, limit+1):
    for b in range(a, limit+1):
        s = a*a + b*b
        if s in square_differences:
            for c, d in square_differences[s]:
                if c < b:
                    break
                else:
                    quads.append((a, b, c, d))

print(len(quads))