Collecting multiple solutions without stopping optimal search

[JasonSloan]

Hi everyone,
I have a question about SCIP / PySCIPOpt.

In my model, when I set limits/solutions=10, the solver sometimes returns a worse objective than when I set max_solutions=1 (which doesn’t set limits/solutions in my code).
I understand limits/solutions stops the solve after N feasible solutions are found, so it may terminate before reaching the optimum.

Is there a way to collect multiple feasible solutions (e.g., 10) but still keep searching for the optimal solution (or continue until the time limit), without stopping
early?
If so, what’s the recommended approach or parameter combination in SCIP?

Thanks a lot for any guidance!

[Joao-Dionisio]

Hey @JasonSloan ! What does the max_solutions variable do? Allowing more solutions shouldn't make SCIP find a worse solution.

Is there a way to collect multiple feasible solutions (e.g., 10) but still keep searching for the optimal solution (or continue until the time limit), without stopping early?

To make sure I understand the issue: you're interested in finding the optimal solution, but want SCIP to find at least 10 solutions in the process, is that it?
The count() method is for collecting feasible solutions, but it's a bit buggy at the moment.

[JasonSloan]

Hi Joao, thanks for the reply!

Let me clarify what I observed and what I’m trying to achieve.

In my code, max_solutions is just a wrapper variable on my side:

• when max_solutions = 1, I do not set limits/solutions at all
• when max_solutions > 1, I set limits/solutions = max_solutions

So effectively:

• max_solutions = 1 → no solution limit, SCIP runs until optimality / time limit
• max_solutions = 10 → limits/solutions = 10, SCIP stops as soon as 10 feasible solutions are found

This explains why allowing more solutions can actually lead to a worse final objective: the solve terminates early before the optimal solution is reached.

What I’m really interested in is:

• Still searching for the optimal solution (or running until the time limit / gap limit)
• While also collecting multiple feasible solutions along the way (e.g. at least 10)

In other words, I don’t want solution collection to be a stopping criterion.

From what I understand now:

• limits/solutions is inherently a termination limit, so it’s not suitable for this use case

• The intended approach seems to be:

  • Do not set limits/solutions
  • Use SCIP’s solution storage (SCIPgetSols, model.getSols() in PySCIPOpt) to retrieve intermediate feasible solutions after the solve
  • Optionally adjust limits/maxsol, limits/time, or gap limits independently

Is that the recommended way to do this in SCIP / PySCIPOpt?
And is there any recommended parameter setup to encourage finding multiple feasible solutions early (without stopping), e.g. via heuristics or emphasis settings?

Regarding count(): thanks for the heads-up. Good to know it’s currently a bit buggy.

Thanks again for the clarification and help!

[Joao-Dionisio]

Well, SCIP stores all the solutions it found in searching for the optimal solution. You are correct that model.getSols() is the method to retrieve them.

To encourage SCIP to find more feasible solutions, you can try doing

from pyscipopt import Model, SCIP_PARAMEMPHASIS

model = Model()
model.setEmphasis(SCIP_PARAMEMPHASIS.COUNTER)

Or if you want more control, you can do

from pyscipopt import Model, SCIP_PARAMSETTING

model = Model()
model.setHeuristics(SCIP_PARAMSETTING.AGGRESSIVE)

And optionally disable things like separation, so that SCIP has more trouble proving optimality, thus having more time for finding primal solutions.

The tutorials might have additional useful information.

(e.g. at least 10)

If you want to solve the problem to optimality, but guarantee that you find $x$ solutions, you can try mimicking the behavior of the count method, but this is more advanced. Essentially, you would need to implement a constraint handler.

1. You optimize the problem and gather any solutions that SCIP found.
2. If you have at least the desired number of solutions, return.
3. Add a constraint forbidding the optimal solution. Go to 1.

But, as I said, this is more advanced, and I would definitely look into changing the settings, as it may be enough.