-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 または同じ数値で正の数}。

ここで、ユーザーに近似値 (u としましょう) を尋ねてから、彼に尋ねます。

4 桁の場合。を満たすこれらの数の組み合わせを見つける必要があります。

方程式: j^a*k^b*l^c*m^d ここで、u の 0.01 以内です。例えば誰かが選んだ

近似値として 238900 を選択し、4 つの値として 14,102329,1936,13 を選択し、次にプログラム

すべての組み合わせ (ie14^-5*102329^-5*..etc) をチェックして、最も近いものを見つけます。

値は 1% 以内で 238900 になります。答えは 14^-5*102329^1*1936^1/2*13^4 です。

あなたは約239103です（uの値の1％以内に実際に近づくことができない場合があります）。

ネストされたループを配置するのに苦労しているだけなので、考えられるすべての組み合わせをチェックします

一度に1つずつチェックするのではなく、同時に。変数が

(a,b,c,d,j,k,l,m) は 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 つを比較しようとしているため、これは意味がありません。

  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 に答える