How to solve this non 0-1 integer Knapsack_Problem in Ruby

Question

Question:

Minimising x1+x2+...+xn

Known k1*x1+k2*x2+...kn*xn = T

k1,k2,...,kn and T are known integers and > 0

k1 > k2 > k3 > ... > kn

All the x are also integers and >= 0

Find all the x

I was trying to use Rglpk and Glpk. But I can't find an example with only one row of matrix. Is this Integer programming? And is it solvable? Many thanks.

---

Some Ruby codes I wrote:

ks = [33, 18, 15, 5, 3]
t = 999

problem = Rglpk::Problem.new
problem.name = "test"
problem.obj.dir = Rglpk::GLP_MIN

rows = problem.add_rows(1)
rows[0].name = "sum of x equals t"
rows[0].set_bounds(Rglpk::GLP_UP, t, t)

cols = problem.add_cols(ks.size)
ks.each_with_index do |k,index|
  cols[index].name = "k: #{k}"
  cols[index].set_bounds(Rglpk::GLP_LO, 0.0, 0.0)
end

problem.obj.coefs = Array.new(ks.size, 1)

problem.set_matrix(ks)

problem.simplex
minimum_x_sum = problem.obj.get
xs = []
cols.each do |col|
  xs << col.get_prim
end
xs

Answer 1

Yes, it is an integer program, a rather famous one, the so-called "knapsack problem". You therefore can solve it with either of the packages you mention (provided the number of variables is not too great) but a much more efficient approach is to use dynamic programming (see the above link). The use of DP here is quite simple to implement. This is one Ruby implementation I found by Googling.

I should mention a few related tidbits. Firstly, your constraint is an equality constraint:

k₁x₁ + k₂x₂ +...+ k_nx_n = T

but this is normally assumed to be an inequality by (DP) knapsack algorithms:

k₁x₁ + k₂x₂ +...+ k_nx_n <= T

To deal with an equality constraint you can either modify the algorithm slightly, or add the term:

M*(T - x₁ + x₂ +...+ x_n)

to the objective you are minimizing, where M is a very large number (10⁶, perhaps), thereby forcing equality at the optimal solution. (When expanded, the coefficient for each x_i becomes 1-M. The constant term MT can be disregarded.)

Two more details:

• DP algorithms permit the variables in the objective to have coefficients other than 1 (and there is no gain in efficiency when all the coefficients equal 1); and
• If the DP algorithm maximizes (rather than minimizes) the objective, you can simply negate the coefficients of the variables in the objective to obtain an optimal solution to the minimization problem.