Subset Sum with Constraints I'm taking a look at what I have identified as being a subset sum problem. 
I have around 650 potential values which could form part of my single sum value. I've began looking into the typical theories to solve for this problem, however I have identified a number of constraints which may allow me to confine the problem further.
For my single sum, there can only be a total of 60 values that make up its sum. In addition to this each day I receive ~ 650 values again, with a new sum (as they change in size each day +/-). 
I am looking for exact match, which typically creates exponential computation, however I believe with the additional constraints I can impose I'm wondering whether I can increase efficiency.
Looking for pointers and best way forward please.
 A: This looks like a fairly small integer programming problem.
Given inputs $S$ (the sum), $K$ (maximum number of items in a subset), $N$ (the number of items), and $c_i$ (individual costs), define the variables $x_i$ as binary indicators of whether element $i$ is in your set. Solve:
\begin{equation*}
\begin{aligned}
& \underset{x_1,\dots,x_N}{\text{maximize}} & & 1 & &\\
& \text{subject to} & &  x_i \in \{0,1\} & i=1,\dots,N\\
& & & \sum_{i=1}^N x_i c_i = S &\\
& & & \sum_{i=1}^N x_i = K &
\end{aligned}
\end{equation*}
The objective is set to 1 because we only care about finding a set which satisfies the constraints. If the constraint $K$ is not an equality constraint (that is, you can have fewer than $K$ elements in the set), solve the problem:
\begin{equation*}
\begin{aligned}
& \underset{x_1,\dots,x_N}{\text{minimize}} & & \sum_{i=1}^N x_i & &\\
& \text{subject to} & &  x_i \in \{0,1\} & i=1,\dots,N\\
& & & \sum_{i=1}^N x_i c_i = S &\\
& & & \sum_{i=1}^N x_i \le K &
\end{aligned}
\end{equation*}
In my experience, choosing 60 out of 650 items is a fairly small problem.  If you are a student, I would recommend using Gurobi which has a free license and fairly straightforward interface for a variety of languages (Matlab, Python, Julia etc).
For example, here is a solution using Julia and Gurobi that runs in much less than a second:
using JuMP
using Gurobi

# Replace this code with your data
N = 650 # Number of elements in set
K = 60 # Constraint on subset size
S = 30 # Constraint on subset cost
c = round(rand(N),1); # Costs
ids = collect(1:N) # UUIDs

# Set the model, and tune tolerances down from their defaults
model = Model(solver=Gurobi.GurobiSolver(OutputFlag=0,TimeLimit=3600,FeasibilityTol=1e-9,OptimalityTol=1e-9,IntFeasTol=1e-9));


@defVar(model, x[1:N], Bin) # N binary variables - x[i] == 1 means we choose i in the subset
@setObjective(model, Min, sum{x[j],j=1:N}) # Find the smallest feasible set.

@addConstraint(model, sum{x[j], j=1:N} <= K)            # Bound on subset size
@addConstraint(model, sum{x[j]*c[j], j=1:N} == S)   # Enforce subset constraint

tic()
status = solve(model)

t = toq();
println("Elapsed time is $t");


if status != :Optimal
    if(status==:UserLimit)
        warn("Time limit hit");
    elseif(status==:Infeasible||status==:infeasible)
        println("No feasible solution found");
    else
        warn("Not solved to optimality \n")
    end
else    
    xsol = find(getValue(x).>0.0)
    indices = ids[xsol]
    println(" Solution has ", size(indices,1), " elements with cost ", sum(c[xsol]), ", and elements $indices");
end

Sample output:
Elapsed time: 0.003736623.
Solution has 650 elements with cost 30.0, and elements ... (omitted because of space).

