2

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

  1. 输入

    • InputMaxRates[] -- 最终解决方案可以从第 i 个保护中获得的最大可能速率
    • inputMinRates[] -- 最终解决方案可以从第 i 个保护中获得的最小可能速率（如果包含）
    • valuesMatrix[][] --第 i 个保护中 100% 内的值的数组
    • targetsArray[] -- 最终框需要覆盖的目标值
    • costOfTheProdects[] -- 如果第 i 个保护，则为 100% 的成本
    • IsRequired[] --boolen 数组来判断第 i 个保护是否必须在最后一个框中

  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;
    }
}
4

0 回答 0