-4

我真的很难解决这个算法。我知道我必须做嵌套循环，但我

无法解决如何解决它。

基本上你有 j^a,k^b,l^c,m^d，其中 a、b、c 和 d 中的每一个都是 17 个之一

数字 {-5、-4、-3、-2、-1、-1/2、-1/3、-1/4、0 或相同的数字，但为正数}。

现在我要向用户询问近似值（比如说你），然后问他

为 4 个数字。我需要找到这些数字的组合，以满足

方程：j^a*k^b*l^c*m^d 其中它在 u 的 0.01 以内。例如有人选择

238900 进行近似，然后选择 14,102329,1936,13 作为他的 4 个值，然后程序

将检查每个组合（即 14^-5*102329^-5*..etc）以找到最接近的

值 238900 在 1% 以内。答案是 14^-5*102329^1*1936^1/2*13^4 给出

你大约 239103 （有时你不能真正接近 u 值的 1% 以内）。

我只是在努力放置嵌套循环，因此它会检查每个可能的组合

同时，而不是一次检查一个。假设变量是

声明 (a,b,c,d,j,k,l,m) asa double 和 q 作为 int：

double [] numbers = {-5.0, -4.0, -3.0, -2.0, -1.0, -1.0/2.0, -1.0/3.0, -1.0/4.0, 0.0, 1.0/4.0, 1.0/3.0, 1.0/2.0, 1.0, 2.0, 3.0, 4.0, 5.0}

while(j - u < k){
    while(k - u < l){
        while(l - u < m){
            while(m < u * 0.01){
                Math.pow(m,numbers[q];
                q++;
            }
            int i = 0;
            if(i == 0){
                q = 0;
                i++;
            }
            Math.pow(l,numbers[q]);
            q++;
        }
        int y = 0;
        if(y == 0){
            q = 0;
            y++;
        }
        Math.pow(k,numbers[q]);
        q++;
    }
    int r = 0;
    if (r == 0){
       q = 0;
       r++
    }
    Math.pow(j,numbers[q]);
    q++;
}
4

1 回答 1

2

通常我会尝试修改您的代码，以便您了解哪里出错了，但我认为在这种情况下这是不可行的。我将指出您可能想要查看的一些内容，然后提供一个适合您提供的约束的实现。

在您的代码中要查看的内容：

  1. 目标u出现在您的每个循环中，例如while (j - u < k). 这没有任何意义，因为您正在尝试计算目标以外的其他内容，然后将两者进行比较。

  2. 约束没有提到指数应该以任何方式相关。因此，在相同的条件下提及j和似乎很奇怪。k

  3. 对 Math.pow 的调用计算出随后被丢弃的结果。

下面是一个简短的程序，可以按照您的描述进行操作。它为您的测试数据生成以下输出：

14.000000^-5.000000 * 102329.000000^1.000000 * 1936.000000^0.500000 * 13.000000^4.000000 = 239102.786480 (approx 238900.000000)

该程序如下所示。随意仔细检查它，并在您的问题发生变化时对其进行调整。

public class Indices
{
    public static void main(String[] args)
    {
        double j = 14.0;
        double k = 102329.0;
        double l = 1936.0;
        double m = 13.0;

        double u = 238900.0;

        double[] r = new Indices().findIndices(j, k, l, m, u);

        if (r == null)
            System.out.println("No solution");
        else
            System.out.format("%f^%f * %f^%f * %f^%f * %f^%f = %f (approx %f)%n", j, r[0], k, r[1], l, r[2], m, r[3], r[4], u);
    }

    double[] findIndices(double j, double k, double l, double m, double u)
    {
        // constants
        double[] indices = new double[] { -5.0, -4.0, -3.0, -2.0, -1.0, -1.0/2.0, -1.0/3.0, -1.0/4.0, 0.0, 1.0/4.0, 1.0/3.0, 1.0/2.0, 1.0, 2.0, 3.0, 4.0, 5.0 };

        double threshold = u * 0.01; // initially 1% of objective value

        double[] bestIndices = null; // initially unknown
        double bestDelta = threshold + 1;

        for (int ai = 0; ai < indices.length; ai++)
        {
            double p1 = Math.pow(j, indices[ai]);

            for (int bi = 0; bi < indices.length; bi++)
            {
                double p2 = p1 * Math.pow(k, indices[bi]);

                for (int ci = 0; ci < indices.length; ci++)
                {
                    double p3 = p2 * Math.pow(l, indices[ci]);

                    for (int di = 0; di < indices.length; di++)
                    {
                        double p4 = p3 * Math.pow(m, indices[di]);

                        double delta = Math.abs(p4 - u);
                        if (delta < bestDelta)
                        {
                            // record new best
                            bestDelta = delta;
                            bestIndices = new double[]
                                {
                                    indices[ai],
                                    indices[bi],
                                    indices[ci],
                                    indices[di],
                                    p4
                                };
                        }
                    }
                }
            }
        }
        return bestIndices;
    }
}
于 2013-09-17T17:33:09.353 回答