59 #ifdef STP_DPTERM_USEDA 88 const SCIP_Real*
const nodes_ub = dpiterator->nodes_ub;
89 const SCIP_Real*
const nodes_dist = dpiterator->nodes_dist;
90 const int nnodes = dpiterator->nnodes;
94 for(
int i = 0; i <
nnodes; i++ )
96 if(
GT(nodes_ub[i], 0.0) )
98 printf(
"%d (nodes_ub=%f) \n", i, nodes_ub[i]);
101 else if(
LE(nodes_dist[i], maxvaliddist) )
103 printf(
"%d (dist=%f) \n", i, nodes_dist[i]);
142 const int prev0 = traces_all[i].prevs[0];
150 if( traces_all[i].prevs[1] != -1 )
162 dpiterator->stack = stack;
172 const int* nodes_termId,
176 return( nodes_termId[node] != -1 && !
stpbitset_bitIsTrue(sol_bitset, nodes_termId[node]) );
188 const SCIP_Real*
const nodes_ub = dpiterator->nodes_ub;
189 STP_Bitset sol_termbits = dpiterator->sol_termbits;
193 for(
int i = 0; i <
nterms; i++ )
196 &&
GT(nodes_ub[terminals[i]], 0.0) )
198 SCIPdebugMessage(
"terminal %d has positive UB, all extension are invalid! \n", terminals[i]);
215 const int nnodes = dpiterator->nnodes;
222 for(
int i = 0; i < nsolcands; i++ )
224 roots_indices[i] = i;
225 roots_cost[i] = -soltraces[i].cost;
233 for(
int i = 1; i < nsolcands; i++ )
235 const int ind = roots_indices[i];
236 const int ind_prev = roots_indices[i - 1];
237 assert(
LE(soltraces[ind_prev].cost, soltraces[ind].cost));
260 iter->tripletstack =
NULL;
261 iter->sol_traces =
NULL;
262 iter->sol_termbits =
NULL;
263 iter->valid_traces =
NULL;
264 iter->valid_bitset =
NULL;
266 iter->sol_nterms = -1;
273 #ifdef STP_DPTERM_USEDA 293 DPITER* iter = *dpiterator;
295 assert(!iter->sol_traces && !iter->sol_termbits);
305 #ifdef STP_DPTERM_USEDA 320 SCIP_Real* RESTRICT nodes_dist = dpiterator->nodes_dist;
321 SCIP_Real* RESTRICT nodes_ub = dpiterator->nodes_ub;
322 int* RESTRICT nodes_pred1 = dpiterator->nodes_previdx0;
323 int* RESTRICT nodes_pred2 = dpiterator->nodes_previdx1;
324 SCIP_Bool* RESTRICT nodes_isValidRoot = dpiterator->nodes_isValidRoot;
325 const int nnodes = dpiterator->nnodes;
327 #ifdef STP_DPTERM_USEDA 328 SCIP_Real* RESTRICT nodes_reddist = dpiterator->nodes_reddist;
330 for(
int i = 0; i <
nnodes; i++ )
331 nodes_reddist[i] = 0.0;
334 dpiterator->extterm = -1;
337 for(
int i = 0; i <
nnodes; i++ )
340 for(
int i = 0; i <
nnodes; i++ )
343 for(
int i = 0; i <
nnodes; i++ )
346 for(
int i = 0; i <
nnodes; i++ )
365 if( findSubsol(dpsolver->
soltree_root, dpiterator->sol_termbits, &subsol) == 0 )
367 dpiterator->sol_traces = subsol->traces;
377 assert(0 &&
"should never happen");
393 assert(!dpiterator->sol_termbits);
394 assert(!dpiterator->valid_bitset);
421 SCIP_Real* RESTRICT nodes_dist = dpiterator->nodes_dist;
422 SCIP_Real* RESTRICT nodes_ub = dpiterator->nodes_ub;
423 int* RESTRICT nodes_previdx0 = dpiterator->nodes_previdx0;
424 int* RESTRICT nodes_previdx1 = dpiterator->nodes_previdx1;
425 SCIP_Bool* RESTRICT nodes_isValidRoot = dpiterator->nodes_isValidRoot;
432 const int nnodes = dpiterator->nnodes;
439 SCIPdebugMessage(
"building Steiner trees from %d candidates \n", nsolcands);
441 for(
int i = 0; i < nsolcands; i++ )
443 const SOLTRACE sol_trace = soltraces[roots_indices[i]];
444 const int sol_root = sol_trace.
root;
447 if(
GT(sol_trace.
cost, nodes_dist[sol_root]) )
450 SCIPdebugMessage(
"building solution with root %d and prev0=%d prev1=%d \n", sol_root,
453 #ifdef STP_DPTERM_USEDA 454 dpiterator->nodes_reddist[sol_root] = sol_trace.redcost;
456 nodes_isValidRoot[sol_root] =
TRUE;
457 nodes_dist[sol_root] = sol_trace.
cost;
458 nodes_ub[sol_root] = 0.0;
459 nodes_nvisits[sol_root]++;
461 nodes_previdx0[sol_root] = sol_trace.
prevs[0];
462 nodes_previdx1[sol_root] = sol_trace.
prevs[1];
464 assert(sol_trace.
prevs[0] != -1 || sol_trace.
prevs[1] == -1);
466 if( sol_trace.
prevs[0] == -1 )
477 const int previdx0 = parent_trace.
prevs[0];
485 const int previdx1 = parent_trace.
prevs[1];
487 assert(previdx0 >= 0);
492 assert(previdx0 != -1);
497 SCIPdebugMessage(
"...merged solution from prev0=%d prev1=%d", previdx0, previdx1);
501 const int curr_root = global_traces[previdx0].root;
502 const SCIP_Real curr_bdist_local = bdist_local + parent_trace.
cost - global_traces[previdx0].cost;
503 const SCIP_Real curr_bdist_global =
MAX(bdist_global, curr_bdist_local);
505 SCIPdebugMessage(
"at pred. solution with index=%d root=%d \n", previdx0, global_traces[previdx0].root);
507 assert(
GE(parent_trace.
cost - global_traces[previdx0].cost, 0.0));
509 if(
LT(sol_trace.
cost, nodes_dist[curr_root]) )
511 nodes_dist[curr_root] = sol_trace.
cost;
512 #ifdef STP_DPTERM_USEDA 513 dpiterator->nodes_reddist[curr_root] = sol_trace.redcost;
517 nodes_nvisits[curr_root]++;
518 nodes_ub[curr_root] = MIN(nodes_ub[curr_root], curr_bdist_global);
526 for(
int i = 0; i <
nnodes; i++ )
528 if( nodes_nvisits[i] < nvalidroots )
534 dpiterator->tripletstack = tripletstack;
552 const int*
const head_csr = csr->
head;
553 const int*
const start_csr = csr->
start;
554 int* RESTRICT nodes_previdx0 = dpiterator->nodes_previdx0;
555 int* RESTRICT nodes_previdx1 = dpiterator->nodes_previdx1;
556 SCIP_Real* RESTRICT nodes_dist = dpiterator->nodes_dist;
557 SCIP_Bool* RESTRICT nodes_isValidRoot = dpiterator->nodes_isValidRoot;
558 const int nnodes = dpiterator->nnodes;
559 STP_Bitset sol_termbits = dpiterator->sol_termbits;
562 const SCIP_Bool breakEarly = (graph->
terms - dpiterator->sol_nterms > 1);
563 const int*
const grad = graph->
grad;
564 #ifdef STP_DPTERM_USEDA 565 SCIP_Real* RESTRICT nodes_reddist = dpiterator->nodes_reddist;
566 const SCIP_Real*
const csr_redcost = dpsolver->dpredcosts->csr_redcosts;
569 assert(nnodes == graph->
knots);
570 assert(dpiterator->extterm == -1);
571 assert(dpiterator->sol_nterms > 0 && dpiterator->sol_nterms <= graph->
terms);
577 for(
int i = 0; i <
nnodes; i++ )
586 while( dheap->
size > 0 )
592 assert(
EQ(nodes_dist[k], k_dist));
598 assert(dpiterator->extterm == -1);
599 dpiterator->extterm = k;
604 const int k_start = start_csr[k];
605 const int k_end = start_csr[k + 1];
606 const SCIP_Bool k_isValid = nodes_isValidRoot[k];
608 for(
int e = k_start; e != k_end; e++ )
610 const int m = head_csr[e];
611 const SCIP_Real distnew = k_dist + cost_csr[e];
613 if(
LT(distnew, nodes_dist[m]) )
615 nodes_isValidRoot[m] = k_isValid;
616 nodes_dist[m] = distnew;
617 nodes_previdx0[m] = k;
618 nodes_previdx1[m] = -1;
619 #ifdef STP_DPTERM_USEDA 620 nodes_reddist[m] = nodes_reddist[k] + csr_redcost[e];
625 else if(
EQ(distnew, nodes_dist[m]) && !k_isValid )
627 nodes_isValidRoot[m] =
FALSE;
632 assert(nodes_termId[m] >= 0);
633 terms_adjCount[nodes_termId[m]]++;
636 if( terms_adjCount[nodes_termId[m]] == grad[m] )
639 assert(dheap->
size == 0);
640 assert(dpiterator->extterm == -1);
641 dpiterator->extterm = m;
649 SCIPdebugMessage(
"...ending extension with root %d \n", dpiterator->extterm);
667 const SCIP_Bool*
const nodes_isValidRoot = dpiterator->nodes_isValidRoot;
668 const SCIP_Real*
const nodes_dist = dpiterator->nodes_dist;
669 const int*
const nodes_previdx0 = dpiterator->nodes_previdx0;
670 const int*
const nodes_previdx1 = dpiterator->nodes_previdx1;
671 const int nnodes = dpiterator->nnodes;
678 for(
int i = 0; i <
nnodes; i++ )
680 if( nodes_isValidRoot[i] )
684 assert(
GE(nodes_dist[i], 0.0) &&
LT(nodes_dist[i],
FARAWAY));
686 #ifdef STP_DPTERM_USEDA 688 ((
SOLTRACE) { {nodes_previdx0[i], nodes_previdx1[i]}, nodes_dist[i], dpiterator->nodes_reddist[i], i }) );
691 ((
SOLTRACE) { {nodes_previdx0[i], nodes_previdx1[i]}, nodes_dist[i], i }) );
702 *hasExtension =
FALSE;
707 *hasExtension =
TRUE;
711 for(
int i = 0; i <
nnodes; i++ )
716 assert(valid_traces[i].root >= 0);
717 rootmap[valid_traces[i].root] = nall + i;
722 if( valid_traces[i].prevs[0] != -1 && valid_traces[i].prevs[1] == -1 )
724 assert(rootmap[valid_traces[i].prevs[0]] >= 0);
725 valid_traces[i].prevs[0] = rootmap[valid_traces[i].prevs[0]];
729 assert(!dpiterator->valid_bitset);
730 dpiterator->valid_bitset = valid_bits;
731 dpiterator->valid_traces = valid_traces;
754 assert(ntraces1 > 0 && ntraces2 > 0);
756 while( pos1 < ntraces1 && pos2 < ntraces2 )
758 assert(pos1 == ntraces1 - 1 || traces1[pos1].root < traces1[pos1 + 1].root);
759 assert(pos2 == ntraces2 - 1 || traces2[pos2].root < traces2[pos2 + 1].root);
761 if( traces1[pos1].root == traces2[pos2].root )
763 #ifdef STP_DPTERM_USEDA 765 { {prevoffset1 + pos1, prevoffset2 + pos2},
766 traces1[pos1].
cost + traces2[pos2].
cost,
767 traces1[pos1].redcost + traces2[pos2].redcost,
772 { {prevoffset1 + pos1, prevoffset2 + pos2},
773 traces1[pos1].
cost + traces2[pos2].
cost,
781 else if( traces1[pos1].root < traces2[pos2].root )
787 assert(traces1[pos1].root > traces2[pos2].root);
796 assert(combined[i - 1].root <= combined[i].root);
818 const int nnodes = dpiterator->nnodes;
820 assert(subsol_traces && combined_traces);
822 while( pos1 < nsubsol_traces || pos2 < ncombined_traces )
824 const int root1 = (pos1 == nsubsol_traces) ? nnodes : subsol_traces[pos1].root;
825 const int root2 = (pos2 == ncombined_traces) ? nnodes : combined_traces[pos2].root;
826 assert(root1 < nnodes || root2 < nnodes);
830 if(
LE(subsol_traces[pos1].cost, combined_traces[pos2].cost) )
837 else if( root1 < root2 )
850 dpsubsol->traces = updated_traces;
868 SOLTRACE* composite_traces = &(dpmisc->global_traces[offsets[
index]]);
869 const int composite_ntraces = offsets[index + 1] - offsets[
index];
875 composite_traces, composite_ntraces, offsets[index]);
877 if( (subsol_pos = findSubsol(dpsolver->
soltree_root, combined_termbits, &subsol)) == 0 )
881 subsolUpdate(scip, combined_traces, dpiterator, subsol);
889 if( 2 * ncombinedterms <= graph->terms )
895 SCIP_CALL( dpterms_dpsubsolInit(scip, &newsol) );
896 newsol->
bitkey = combined_termbits;
897 newsol->traces = combined_traces;
920 if( findSubsol(dpsolver->
soltree_root, sol_termstoggled, &dpsubsol) == 0 )
928 assert(ntraces1 > 0 && ntraces2 > 0);
929 assert(valid_traces && toggled_traces);
936 while( pos1 < ntraces1 && pos2 < ntraces2 )
938 assert(pos1 == ntraces1 - 1 || valid_traces[pos1].root < valid_traces[pos1 + 1].root);
939 assert(pos2 == ntraces2 - 1 || toggled_traces[pos2].root < toggled_traces[pos2 + 1].root);
941 if( valid_traces[pos1].root == toggled_traces[pos2].root )
943 const SCIP_Real newcost = valid_traces[pos1].cost + toggled_traces[pos2].cost;
949 dpmisc->
opt_prev[0] = toggled_traces[pos2].prevs[0];
950 dpmisc->
opt_prev[1] = toggled_traces[pos2].prevs[1];
955 else if( valid_traces[pos1].root < toggled_traces[pos2].root )
961 assert(valid_traces[pos1].root > toggled_traces[pos2].root);
980 const int nextensions =
StpVecGetSize(dpiterator->valid_traces);
982 assert(nextensions > 0);
983 assert(dpiterator->sol_termbits);
984 assert(dpiterator->valid_bitset);
986 if( 3 * dpiterator->sol_nterms <= graph->
terms )
991 dpiterator->valid_bitset, nsubsets, dpsolver->
dpstree) );
998 for(
int i = 0; i < nextensions; i++ )
1000 StpVecPushBack(scip, dpmisc->global_traces, dpiterator->valid_traces[i]);
1002 StpVecPushBack(scip, dpmisc->global_termbits, dpiterator->sol_termbits);
1003 StpVecPushBack(scip, dpmisc->global_termbitscount, dpiterator->sol_nterms);
1007 dpiterator->sol_termbits =
NULL;
1008 dpiterator->valid_bitset =
NULL;
1029 if( !hasExtensions )
1034 intersections = dpterms_streeCollectIntersects(scip, dpiterator->sol_termbits,
1035 dpiterator->valid_bitset, dpsolver->
dpstree);
1039 const int pos = intersections[i];
1040 assert(0 <= pos && pos < dpmisc->global_size);
1043 if( 2 * dpiterator->sol_nterms + dpmisc->global_termbitscount[pos] > nterms )
1073 const int*
const head_csr = csr->
head;
1074 const int*
const start_csr = csr->
start;
1075 SCIP_Real* RESTRICT nodes_ub = dpiterator->nodes_ub;
1076 const int nnodes = dpiterator->nnodes;
1078 assert(nnodes == graph->
knots);
1082 for(
int i = 0; i <
nnodes; i++ )
1084 if(
GT(nodes_ub[i], 0.0) )
1089 while( dheap->
size > 0 )
1096 assert(
EQ(nodes_ub[k], k_ub));
1099 const int k_start = start_csr[k];
1100 const int k_end = start_csr[k + 1];
1102 for(
int e = k_start; e != k_end; e++ )
1104 const int m = head_csr[e];
1105 const SCIP_Real ubnew = k_ub - cost_csr[e];
1107 if(
GT(ubnew, nodes_ub[m]) )
1109 nodes_ub[m] = ubnew;
1129 const int*
const head_csr = csr->
head;
1130 const int*
const start_csr = csr->
start;
1131 const SCIP_Real*
const nodes_dist = dpiterator->nodes_dist;
1132 const SCIP_Real*
const nodes_ub = dpiterator->nodes_ub;
1133 SCIP_Bool* RESTRICT nodes_isValidRoot = dpiterator->nodes_isValidRoot;
1134 STP_Bitset sol_bitset = dpiterator->sol_termbits;
1136 const int nnodes = dpiterator->nnodes;
1140 const int extterm = dpiterator->extterm;
1141 int termcount = graph->
terms - dpiterator->sol_nterms;
1142 #ifdef STP_DPTERM_USEDA 1143 SCIP_Real* RESTRICT nodes_reddist = dpiterator->nodes_reddist;
1144 const SCIP_Real cutoffbound = dpsolver->dpredcosts->cutoffbound;
1147 assert(nnodes == graph->
knots);
1148 assert(termcount >= 1);
1161 for(
int i = 0; i <
nnodes; i++ )
1162 nodes_mindist[i] = -1.0;
1164 nodes_mindist[extterm] = nodes_dist[extterm];
1169 while( dheap->
size > 0 )
1175 heapnode_dist *= -1.0;
1176 assert(
EQ(nodes_mindist[heapnode], heapnode_dist));
1177 assert(
GE(heapnode_dist, 0.0));
1186 const int m_start = start_csr[m];
1187 const int m_end = start_csr[m + 1];
1193 if( --termcount == 0 )
1195 maxvaliddist = heapnode_dist;
1197 assert(dheap->
size == 0);
1202 for(
int e = m_start; e != m_end; e++ )
1205 const int q = head_csr[e];
1207 if(
GT(nodes_ub[q], 0.0) )
1212 dist_new = MIN(heapnode_dist, nodes_dist[q]);
1213 assert(
GE(dist_new, 0.0));
1215 if(
GT(dist_new, nodes_mindist[q]) )
1217 if(
LE(heapnode_dist, nodes_dist[q]) )
1219 SCIPdebugMessage(
"update and push-back node %d (dist=%f) \n", q, nodes_dist[q]);
1224 assert(
EQ(dist_new, nodes_dist[q]));
1228 nodes_mindist[q] = dist_new;
1234 #ifdef STP_DPTERM_USEDA 1235 maxvaliddist = MIN(maxvaliddist, dpsolver->dpredcosts->upperbound);
1238 for(
int i = 0; i <
nnodes; i++ )
1240 if(
GT(nodes_dist[i], maxvaliddist) )
1241 nodes_isValidRoot[i] =
FALSE;
1242 #ifdef STP_DPTERM_USEDA 1244 else if(
GT(nodes_reddist[i], cutoffbound) )
1247 nodes_isValidRoot[i] =
FALSE;
1256 dpiterator->stack = stack;
1270 assert(dpiterator->sol_traces == dpiterator->
dpsubsol->traces);
1272 if( dpiterator->sol_termbits )
1278 dpiterator->sol_traces =
NULL;
1299 assert(scip && graph && dpsolver && wasSolved);
1317 if( graph->
terms - dpiterator->sol_nterms > 1 )
1335 assert(!dpsolver->solnodes);
1340 dpsolver->solnodes = getSolnodesFinal(scip, dpmisc, dpiterator);
static SCIP_Bool allExtensionsAreInvalid(const GRAPH *graph, const DPSOLVER *dpsolver, const DPITER *dpiterator)
static SCIP_RETCODE dpiterInit(SCIP *scip, const GRAPH *graph, DPITER **dpiterator)
static volatile int nterms
static SCIP_RETCODE dpiterAddNewPrepare(SCIP *scip, DPMISC *dpmisc, DPITER *dpiterator, SCIP_Bool *hasExtension)
#define StpVecGetSize(vec)
static void dpiterPopSol(SCIP *scip, DPSOLVER *dpsolver, DPITER *dpiterator)
static void dpiterGetNextSol(SCIP *scip, DPSOLVER *dpsolver, DPITER *dpiterator)
#define SCIPallocClearBufferArray(scip, ptr, num)
#define SCIPfreeMemoryArray(scip, ptr)
struct dynamic_programming_iterator DPITER
static void debugPrintSeparator(SCIP_Real maxvaliddist, const DPITER *dpiterator)
#define SCIPallocMemoryArray(scip, ptr, num)
enum SCIP_Retcode SCIP_RETCODE
SCIP_RETCODE dpterms_coreSolve(SCIP *scip, GRAPH *graph, DPSOLVER *dpsolver, SCIP_Bool *wasSolved)
void graph_heap_clean(SCIP_Bool, DHEAP *)
Dynamic programming solver for Steiner tree (sub-) problems with small number of terminals.
static void stpbitset_print(STP_Bitset bitset)
#define StpVecPopBack(vec)
static void updateIncumbent(SCIP *scip, DPSOLVER *dpsolver, DPITER *dpiterator)
void graph_heap_deleteMin(int *, SCIP_Real *, DHEAP *)
#define StpVecReserve(scip, vec, _size_)
#define SCIPrbtreeDelete(root, node)
void SCIPsortDownRealInt(SCIP_Real *realarray, int *intarray, int len)
static void propagateUBs(const GRAPH *graph, DPSOLVER *dpsolver, DPITER *dpiterator)
#define SCIPfreeBufferArray(scip, ptr)
SCIP_RETCODE stpprioqueue_insert(SCIP *scip, void *data, int newkey, STP_PQ *prioqueue)
header only, simple implementation of an STL like vector
static void dpiterSetDefault(SCIP *scip, DPITER *dpiterator)
void stpprioqueue_deleteMin(void **data, int *key, STP_PQ *prioqueue)
static SCIP_RETCODE subtreesAddNew(SCIP *scip, const GRAPH *graph, DPSOLVER *dpsolver, DPITER *dpiterator)
static SCIP_Bool stpbitset_areEqual(STP_Bitset bitset1, STP_Bitset bitset2)
static void dpiterFree(SCIP *scip, DPITER **dpiterator)
priority queue with integer keys
static SCIP_RETCODE getOrderedRootIndices(SCIP *scip, DPITER *dpiterator, int *roots_indices)
static SCIP_RETCODE combineWithIntersecting(SCIP *scip, const GRAPH *graph, int index, DPSOLVER *dpsolver, DPITER *dpiterator)
static STP_Bitset stpbitset_newNot(SCIP *scip, STP_Bitset bitset1, int size)
header only, simple implementation of a bitset
struct trace_triplet TTRIPLET
#define SCIPallocBufferArray(scip, ptr, num)
static STP_Bitset stpbitset_newCopy(SCIP *scip, STP_Bitset bitsetOrg)
static void dpterms_dpsubsolFree(SCIP *scip, DPSUBSOL **subsol)
static STP_Bitset stpbitset_new(SCIP *scip, int maxnbits)
static SCIP_RETCODE subtreesRemoveNonValids(SCIP *scip, const GRAPH *graph, DPSOLVER *dpsolver, DPITER *dpiterator)
static void subsolUpdate(SCIP *scip, STP_Vectype(SOLTRACE) combined_traces, DPITER *dpiterator, DPSUBSOL *dpsubsol)
static void stpbitset_free(SCIP *scip, STP_Bitset *bitset)
static SCIP_Bool stpbitset_bitIsTrue(STP_Bitset bitset, int index)
Dynamic programming internals for Steiner tree (sub-) problems with small number of terminals...
#define SCIPfreeMemory(scip, ptr)
static void dpiterFinalizeSol(SCIP *scip, DPITER *dpiterator)
#define SCIPfreeBuffer(scip, ptr)
SCIP_Bool stpprioqueue_isClean(const STP_PQ *prioqueue)
static STP_Bitset stpbitset_newOr(SCIP *scip, STP_Bitset bitset1, STP_Bitset bitset2)
#define SCIPrbtreeInsert(r, p, c, n)
SCIP_RETCODE dpterms_streeInsert(SCIP *scip, STP_Bitset termsmark, STP_Bitset rootsmark, int64_t nsubsets, DPSTREE *dpstree)
SCIP_Bool SCIPisStopped(SCIP *scip)
#define StpVecFree(scip, vec)
static SCIP_RETCODE subtreesBuild(SCIP *scip, DPMISC *dpmisc, DPITER *dpiterator)
static int stpbitset_getPopcount(STP_Bitset bitset)
int graph_get_nNodes(const GRAPH *)
static DPSUBSOL ** subsol
intrusive red black tree datastructure
#define SCIPallocMemory(scip, ptr)
SCIP_Bool graph_knot_isInRange(const GRAPH *, int)
#define StpVecPushBack(scip, vec, value)
#define BMSclearMemoryArray(ptr, num)
static void stpbitset_setBitTrue(STP_Bitset bitset, int index)
static SCIP_RETCODE subtreesExtend(SCIP *scip, const GRAPH *graph, DPSOLVER *dpsolver, DPITER *dpiterator)
static SCIP_Bool nodeIsNonSolTerm(STP_Bitset sol_bitset, const int *nodes_termId, int node)
void graph_heap_correct(int, SCIP_Real, DHEAP *)
static SCIP_RETCODE subtreesAddNewFinalize(SCIP *scip, const GRAPH *graph, DPSOLVER *dpsolver, DPITER *dpiterator)