Java 查找^3+的所有结果；b^3=c^3+；d^3，由Math.pow（）方法引起的问题

问题：打印方程式的全部+ve整数解

a^3+b^3=c^3+d^3

其中

a、b、c、d是整数bw
1到1000
面临
Math.pow（）函数的问题

所以我写了两个代码，一个是蛮力，另一个有点优化。
第一个显示正确的输出，而第二个显示不正确，这是由于功率功能

Math.pow（0,1/3）
=
1
，而它应该是
0

class Find_a3_b3__c3_d3{
    // final static int n = 100;

    // solution 1  : BRUTE FORCE
    public static void bruteForce(){        // O(N^4)
        int n = 5;

        int resultCount = 0;
        for(int a=0; a<n ; a++){
            for(int b=0; b<n; b++){
                for(int c=0; c<n; c++){
                    for(int d=0; d<n; d++){
                        int a_3 = a*a*a;
                        int b_3 = b*b*b;
                        int c_3 = c*c*c;
                        int d_3 = d*d*d;
                        if(a_3 + b_3 == c_3 + d_3){
                            System.out.println((resultCount++) + "   a: "+a +"  b: "+b + "   ---    c: "+c + "  d: "+d );
                            break;
                        }
                    }
                }
            }
        }
        System.out.println("\n\n");
    }



    // solution 2  : BRUTE FORCE
    // idea is : as we know d is going to have one value for each pair of a,b & c so
    //           if we know a b & c , then we can find d by the relation  cubeRoot (a_3 + b_3 - c_3);
    public static void littleBetter(){        // O(N^4)
        int n = 5;

        int resultCount = 0;
        for(int a=0; a<n ; a++){
            for(int b=0; b<n; b++){
                for(int c=0; c<n; c++){
                    int a_3 = a*a*a;
                    int b_3 = b*b*b;
                    int c_3 = c*c*c;
                    System.out.println(a +" " + b+" " + c +" ");
                    System.out.println(a_3 +" " + b_3+" " + c_3 +" " + Math.pow(a_3 + b_3 - c_3, 1/3));
                    int d = (int) Math.pow(a_3 + b_3 - c_3, 1/3);
                    int d_3 = d*d*d;

                    if(a_3 + b_3 == c_3 + d_3){
                        System.out.println((resultCount++) + "   a: "+a +"  b: "+b + "   ---    c: "+c + "  d: "+d );
                    }
                }
            }
        }
        System.out.println("\n\n");
    }


    public static void main(String[] args) {
        bruteForce();//          O(n^4)
        littleBetter(); //       O(n^3)

        System.out.println( Math.pow(0,1/3));
        System.out.println( Math.pow(0,1));
        System.out.println( Math.pow(0,0));
        System.out.println( Math.pow(34,0));
        System.out.println( Math.pow(34,-0));
        System.out.println( Math.pow(0,1));
    }
}

类查找\uA3\uB3\uC3\uD3{
//最终静态int n=100；
//解决方案1：暴力
公共静态void bruteForce（）{//O（N^4）
int n=5；
int resultCount=0；
对于（int a=0；a当你除以两个整数时，答案也变成一个整数，这是因为你得到的是1而不是零。
1/3
等于零，而
Math.pow（0,0）
等于1。相反，你可以使用
Math.pow（0,1./3））
得到0。

更新
您可以查看已提供的更好的解决方案。
当您除以两个整数时，答案也会变成一个整数，这是因为您得到的是1而不是零。
1/3
等于零且
Math.pow（0,0）
等于1。相反，您可以使用
Math.pow（0,1./3））
获取0。

更新
您可以检查以查看已提供的更好的解决方案。
如我在评论中所述，您遇到的问题可能是由于1/3被评估为0。将1或3转换为浮点数应该可以解决此问题

然而，我建议进一步优化：计算x=1到n的x^3，并将结果存储在数组和散列集中。然后，对于数组中3个数字的每一个组合，如果a+b-c在散列集中，则进行测试（由于a+b的对称性，您还可以通过在b上稍微进行迭代来节省一些重复项）

编辑：当然，我的优化牺牲了空间复杂性。
正如我在评论中所说的，您遇到的问题可能是由于1/3被评估为0。将1或3转换为浮点数应该可以解决这个问题

然而，我建议进一步优化：计算x=1到n的x^3，并将结果存储在数组和散列集中。然后，对于数组中3个数字的每一个组合，如果a+b-c在散列集中，则进行测试（由于a+b的对称性，您还可以通过在b上稍微进行迭代来节省一些重复项）

编辑：当然，我的优化牺牲了空间复杂度。
1/3=0（默认情况下1/3被视为整数除法）。Try（double）1/31/3=0（默认情况下1/3被视为整数除法）。Try（double）1/3这个问题是因为1不能被3除掉。当你将1除以3时，你得到0.3333…33。这样
Math.pow（64，0.3）
equals
3.4822022531844965
和
Math.pow（64，0.33）
equals
3.9449308179734368
等等。这个问题可以通过使用
Math.round（）简单地解决
。有关浮点的更多信息，请参阅下面的链接。这个问题是因为1不能被3除。当你将1除以3时，得到0.3333…33。因此，这样
Math.pow（64，0.3）
等于
3.4822022531844965
和
Math.pow（64，0.33）
等于
3.9449308179734368
等等。这个问题可以通过使用
Math.round（）简单地解决
。有关浮点的更多信息，请参阅下面的链接。你能将代码粘贴到stackoverflow上吗？我不喜欢打开链接。我认为这是更好的答案。你能将代码粘贴到stackoverflow上吗？我不喜欢打开链接。我认为这是更好的答案。