如何正确使用 Math.Pow()？

Question

我想找到方程的所有正整数解 a^3 + b^3 = c^3 + d^3 其中 a,b,c,d 是 1 到 1000 之间的整数；

for (int a = 1; a <= 1000; ++a)
{
    for (int b = 1; b <= 1000; ++b)
    {
        for (int c = 1; c <= 1000; ++c)
        {
            for (int d = 1; d <= 1000; ++d)
            {
                if (Math.Pow(a, 3) + Math.Pow(b, 3) == Math.Pow(c, 3) + Math.Pow(d, 3))
                {
                     Console.WriteLine("{0} {1} {2} {3}", a,b,c,d);
                }
            }
      }
}

我知道d = Math.Pow(a^3 + b^3 - c^3, 1/3)，所以

for (int a = 1; a <= 1000; ++a)
{
    for (int b = 1; b <= 1000; ++b)
    {
        for (int c = 1; c <= 1000; ++c)
        {
            int d = (int)Math.Pow(Math.Pow(a, 3) + Math.Pow(b, 3) - Math.Pow(c, 3), 1/3);

            if (Math.Pow(a, 3) + Math.Pow(b, 3) == Math.Pow(c, 3) + Math.Pow(d, 3))
            {
                Console.WriteLine("{0} {1} {2} {3}", a,b,c,d);
            }
        }
   }
}

但是第二种算法产生的结果数量要少得多。我的代码中的错误在哪里？

我尝试(double)1/3，但第二个算法给我的结果仍然比第一个少

Answer 1

这些答案几乎没有一个是正确的。

你的问题是：

我的代码中的错误在哪里？

如果您使用双精度算术来解决整数问题，那么您做错了。完全不要使用Math.Pow，尤其不要使用它来提取立方根并期望你会得到一个精确的整数答案。

那么你应该如何实际解决这个问题呢？

让我们更聪明一点，不要做不必要的工作。您的程序发现 1³ + 12³ = 9³ + 10³，但也发现 12³ + 1³ = 10³ + 9³，以此类推。如果你知道第一个，那么你可以很容易地知道第二个。

那么我们应该怎么做才能提高效率呢？

首先，b 必须大于 a。这样我们就不会浪费任何时间来计算 1³ + 12³ = 12³ + 1³。

同样，d 必须大于 c。

现在，我们也可以说c 和d 必须在 a 和b 之间。 你明白为什么吗？

一旦我们实施了这些限制：

    for (int a = 1; a <= 1000; ++a)
        for (int b = a + 1; b <= 1000; ++b)
            for (int c = a + 1; c < b; ++c)
                for (int d = c + 1; d < b; ++d)
                    if (a * a * a + b * b * b == c * c * c + d * d * d)
                        Console.WriteLine($"{a} {b} {c} {d}");

你的程序变得更快了。

现在，如果您愿意以更少的时间换取更多的内存，还有一些方法可以让它更快。你能想到这个程序浪费时间的一些方法吗？相同的计算重复进行多少次？我们如何才能改善这种情况？

我们可能会注意到，例如a * a * a 每次都通过三个内部循环计算！

    for (int a = 1; a <= 1000; ++a)
    {
        int a3 = a * a * a;
        for (int b = a + 1; b <= 1000; ++b)
        {
            int b3 = b * b * b;
            int sum = a3 + b3;
            for (int c = a + 1; c < b; ++c)
            {
                int c3 = c * c * c;
                int d3 = sum - c3;
                for (int d = c + 1; d < b; ++d)
                    if (d3 == d * d * d)
                        Console.WriteLine($"{a} {b} {c} {d}");
            }
        }
    }

但我们可以比这更聪明。例如：如果我们创建一个 Dictionary<int, int> 将立方体映射到它们的立方体根会怎么样？他们只有1000个！那么我们可以说：

    for (int a = 1; a <= 1000; ++a)
    {
        int a3 = a * a * a;
        for (int b = a + 1; b <= 1000; ++b)
        {
            int b3 = b * b * b;
            int sum = a3 + b3;
            for (int c = a + 1; c < b; ++c)
            {
                int c3 = c * c * c;
                int d3 = sum - c3;
                if (dict.HasKey(d3))
                {
                    d = dict[d3];
                    Console.WriteLine($"{a} {b} {c} {d}");
                }
            }
        }
    }

现在您不必计算 d 的立方或立方根；你只要看看它是否是一个立方体，如果是，它的立方根是什么。

Answer 2

即使是双精度数，1/3 也不能用任何 IEEE 浮点类型精确表示。

因此，您实际上并不是在计算一个值的立方根，而是将该值提高到 0.333333333333333333333333333334 的幂次方或稍微偏离的版本。这会引入舍入误差，导致误差因素增加。

考虑 a = 995、b = 990、c = 990 的情况：您的第一个循环将生成 d = 995 的匹配项，但由于舍入错误，您的计算会产生 d = 994，这与您的条件不匹配。这很少会匹配，这解释了您所看到的结果。

要解决此问题，您可以完全使用浮点数，但这会变得一团糟，因为即使在这种情况下，由于表示问题，您也必须检查范围，并且只有在找到可能合适的范围后，您才必须检查整数版本。另一种解决方案是从数学的角度而不是蛮力来解决这个问题，尽管这可能需要内核方法并且变得非常混乱。

Answer 3

替换

int d = (int)Math.Pow(Math.Pow(a, 3) + Math.Pow(b, 3) - Math.Pow(c, 3), 1/3);

与

int d = (int)Math.Round(Math.Pow(Math.Pow(a, 3) + Math.Pow(b, 3) - Math.Pow(c, 3), 1.0/3), 0);
if(d > 1000) continue; // Restrict solutions as in brute force algorithm

修复的两个错误是，

1. 1/3 计算为整数除法，结果为 0。使用 1.0/3 强制进行浮点除法。
2. 由于浮点错误，计算可能会返回3.999999994 而不是4。当转换为整数时，它会被截断为3，从而有效地删除解决方案。使用 Math.Round(3.999999994, 0) 将其向上舍入为 4.0，然后将其作为整数转换为 4。

Answer 4

您的问题是，这一行的结果：int d = (int)Math.Pow(Math.Pow(a, 3) + Math.Pow(b, 3) - Math.Pow(c, 3), 1/3); 可以是非整数值，这不能满足您的要求。但是通过将其转换为int，您可以获得更多的解决方案。

您应该将 d 更改为 double，然后检查 d 是否为 1 到 1000 之间的整数值：

double d = Math.Pow(Math.Pow(a, 3) + Math.Pow(b, 3) - Math.Pow(c, 3), 1.0/3.0);
double epsilon = 0.000000001;
double dint = Math.Round(d, 0);
if (dint<=d+epsilon && dint>=d-epsilon && dint>=1-epsilon && dint<=1000+epsilon)
{
   Console.WriteLine("{0} {1} {2} {3}", a,b,c,d);
}

编辑：我添加了一个 epsilon 以确保您的双重比较有效