我有目标值的数组，并且组件列表需要选择每个或某些组件的最佳比率，以使最终回报率等于或小于100％，并用Java中的最低成本满足目标数组 这是我尝试用来解决问题的代码，它可以根据需要正常工作，但是需要很长时间并且需要一些优化

1. 输入

   • InputMaxRates []-最终解决方案可以从第i个保护中获得的最大可能速率
   • inputMinRates []-最终解决方案可以从ith保护中获得的最小可能速率
   • valuesMatrix [] []-第i个Protect中100％内的值的数组
   • targetsArray []-最后一个框需要覆盖的目标值
   • costOfTheProdects []-如果使用ith保护，则成本为100％
   • isrequired []-布尔数组，用于判断ith保护是否必须在最后一个框中

2. 输出

   具有输入大小的
   • 阵列可以以最小的成本/最佳比例满足每个保护目标的数量 输出必须是总数不超过100的数组，如果没有可能，则返回-1的数组

任何人都可以提供帮助，这是我的代码

import java.util.Arrays;
import java.util.Vector;
import javax.swing.JOptionPane;
import javax.swing.JTable;

public class AISolver {

    double InputMaxRates[],inputMinRates[],costOfTheProdects[];
    double targetsArray[];
    double[] bestRatios = null;
    double[] bestvalues = null;
    boolean isrequired[];
    double minPriceCost = 1000000000;
    int minPriceMet = -1;
    double[][] valuesMatrix;
    int numberOfTargets = 9;//number of vectors
    int numberOfRows = 0;

    public AISolver(double[] InputMaxRates,double[] inputMinRates,double[][] valuesMatrix,double[] targetsArray,boolean isrequired[],double[] costOfTheProdects) {
        this.InputMaxRates = InputMaxRates;
        this.inputMinRates = inputMinRates;
        this.valuesMatrix = valuesMatrix;
        this.targetsArray = targetsArray;
        this.costOfTheProdects = costOfTheProdects;
        this.isrequired = isrequired;
        numberOfTargets = targetsArray.length;
        numberOfRows = inputMinRates.length;
    }

    int hitflag = 0;

    private void checkTheVictor(Vector<Double> v) {
        double[] thisRatioValues = getTheNewValues(v);
        double thisRatioCost = calcCostFromRates(v);
        int checkmet = checkMeetTargets(thisRatioValues);
        if (checkmet > 0 && checkmet >= minPriceMet) {
            if (checkmet > minPriceMet) {
                //JOptionPane.showmessagedialog(dataTable,"Meet -> " + minPriceMet);
                minPriceCost = 1000000000;
            }
            minPriceMet = checkmet;
            if (checkmet == numberOfTargets) {
//                JOptionPane.showmessagedialog(dataTable,"Meet -> " + minPriceMet + " cost = " + thisRatioCost);
//                if (hitflag == 0) {
//                    minPriceCost = 1000000000;
//                }
                if (minPriceCost > thisRatioCost) {
                    minPriceCost = thisRatioCost;
                    bestRatios = new double[numberOfRows];
                    for (int i = 0; i < bestRatios.length; i++) {
                        try {
                            bestRatios[i] = v.get(i);
                        } catch (Exception e) {
                            bestRatios[i] = 0;
                        }
                    }
                    bestvalues = new double[numberOfTargets];
                    for (int i = 0; i < thisRatioValues.length; i++) {
                        bestvalues[i] = thisRatioValues[i];
                    }
                }
            }
        }

    }

    public double[] bestRatioFinder(Vector<Double> v) {
        if ((v.size() == numberOfRows && getRatesVectorSum(v) <= 100) || getRatesVectorSum(v) >= 100) {
            checkTheVictor(v);
        } else if (inputMinRates[v.size()] == InputMaxRates[v.size()]) {
            v.add(inputMinRates[v.size()]);
            bestRatioFinder(v);
        } else {
            //leave the prodect option
            if (isrequired[v.size()] == false) {
                v.add(0.0);
//                new Thread(() -> {
//                    Vector<Double> vt = new Vector<>();
//                    for (Double tx : v) {
//                        vt.add(tx);
//                    }
//                    bestRatioFinder(v);
//                }).start();
                bestRatioFinder(v);
                v.removeElementAt(v.size() - 1);
            }
            //contune
            Double maxPossibleRate = Math.min(101 - getRatesVectorSum(v),InputMaxRates[v.size()] + 1);
            for (Double i = inputMinRates[v.size()]; i < maxPossibleRate; i++) {
                v.add(i);
                //System.out.println(Arrays.toString(v.toArray()));
//                new Thread(() -> {
//                    Vector<Double> vt = new Vector<>();
//                    for (Double tx : v) {
//                        vt.add(tx);
//                    }
//                    bestRatioFinder(v);
//                }).start();
                bestRatioFinder(v);
                v.removeElementAt(v.size() - 1);
            }
        }
        return bestRatios;
    }

    private int getRatesVectorSum(Vector<Double> v) {
        int sum = 0;
        for (int i = 0; i < v.size(); i++) {
            Double el = v.elementAt(i);
            sum += el;
        }
        return sum;
    }

    private double calcCostFromRates(Vector<Double> v) {
        double sum = 0;
        for (int i = 0; i < v.size(); i++) {
            Double el = v.elementAt(i);
            double cost = costOfTheProdects[i];
            sum += el * cost;
        }
        return sum;
    }

    private double[] getTheNewValues(Vector<Double> v) {
        //need to update
        double[] gvalus = new double[numberOfTargets];
        for (int rowCounter = 0; rowCounter < v.size(); rowCounter++) {
            Double el = v.elementAt(rowCounter);
            for (int colCounter = 0; colCounter < numberOfTargets; colCounter++) {
                Double cItemRatio = el;
                double theCourntvalueOfTheItem = valuesMatrix[rowCounter][colCounter];
                double theValueToAdd = cItemRatio * theCourntvalueOfTheItem / 100;
                gvalus[colCounter] += theValueToAdd;
            }
        }
        return gvalus;
    }

    private int checkMeetTargets(double[] ratvals) {
        int met = 0;
        for (int i = 0; i < ratvals.length; i++) {
            if (ratvals[i] >= targetsArray[i]) {
                met++;
            }
        }
        return met;
    }
}