Question

I am trying to develop an optimization function that will determine which elements in list of doubles when added together will be less than a specified threshold values. The elements can be used multiple times.

For example if my list of elements is

{1,3,7,10}  

and my threshold is 20 I would expect my result to be

1
3
7
10
10, 10
10, 7
10, 7, 3
10,7,1
10,7,1,1
10,7,1,1,1
7,7
7,7,3
7,7,1
7,7,1,1
7,7,1,1,1
...

I expect that the answer to this question will probably be a recursive call and probably could be found in a textbook, but I don’t know how to properly phrase the question to find the answer. Help from this group of experts would be appreciated.

Answer 1

This program works, and seems to be the simplest solution. All results are sorted ascending.

  private static final HashSet<ArrayList<Double>> lists = 
       new HashSet<ArrayList<Double>>(); // all of the combinations generated

  private static final double[] elements = {10, 7, 3, 1};

  public static void main(String[] args) {
    combine(20, new ArrayList<Double>());
    for (ArrayList<Double> set : lists) {
      System.out.println(set);
    }
  }

  private static void combine(final double limit, ArrayList<Double> stack) {
    // iterates through the elements that fit in the threshold
    for (double item : elements) {
      if (item < limit) {
        final ArrayList<Double> nextStack = new ArrayList<Double>(stack);
        nextStack.add(item);
        // a sort is necessary to let the HashSet de-dup properly
        Collections.sort(nextStack);
        lists.add(nextStack);
        combine(limit - item, nextStack);
      }
    }
  }

This type of combinatoric problem, though, generates many results. If you are more concerned with performance than code readability and simplicity, I can optimize further.

c#:

static void Main(string[] args)
    {
        Run();
    }

    static public void Run()
    {
        Combine(20, new List<Double>());
        foreach (List<Double> set in lists)
        {

            Debug.Print(set.ToString());
        }
    }
    private static HashSet<List<Double>> lists =
        new HashSet<List<Double>>(); // all of the combinations generated

    private static double[] elements = { 10, 7, 3, 1 };

    private static void Combine(double limit, List<Double> stack)
    {
        // iterates through the elements that fit in the threshold
        foreach (double item in elements)
        {
            if (item < limit)
            {
                List<Double> nextStack = new List<Double>(stack);
                nextStack.Add(item);
                // a sort is necessary to let the HashSet de-dup properly
                nextStack.Sort();
                lists.Add(nextStack);
                Combine(limit - item, nextStack);
            }
        }
    }