find the best ratios to minimize the cost of the box ( 100 % ratio or less ) from multiple values

Question

I have array of targets values and list of components need to pick the best ratio of each or some of it that make the final return ratio is 100 % or less and meet the targets array with minimum cost in java here is the code that i tried to solve the problem with and it work correctly as i need but take so long time and need some optimization

1. inputs

   • InputMaxRates[] --the max possible rate that the final solution can have from the ith protect
   • inputMinRates[] --the min possible rate that the final solution can have from the ith protect if it included
   • valuesMatrix[][] --array of the values inside 100% in the ith protect
   • targetsArray[] --the target values that the final box need to cover
   • costOfTheProdects[] --the cost of 100% if the ith protect
   • IsRequired[] --boolen array to tell if the ith protect must be in the final box

2. output

   • array with size of input protects number with the best ratio of each / some of the protects that meet the targets with minimum cost output must be array with total of 100 or less and if no possible solution return array with -1

anyone can help please here is my code

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