Альтернативные стратегии ветвления в Gecode

Я пишу здесь, чтобы спросить, есть ли способ чередовать разные стратегии ветвления. Позвольте мне объяснить, у меня есть эффективная стратегия ветвления, которую мы назовем стратегией . Самая большая проблема заключается в том, что стратегия не может использоваться так часто. Поэтому, когда я не могу использовать стратегию , Я использую другую стратегию, которую я назову стратегией В, который менее эффективен.

В документации сказано, что:

Отраслевой заказ. Создание ветки регистрирует его в своем домашнем пространстве. Пространство поддерживает очередь своих ответвлений в том смысле, что ответвитель, который зарегистрирован первым, также используется первым для
ветвления. Первый филиал в очереди филиалов упоминается как текущий филиал.

Итак, я предположил, что если я отправлю ответвление А, то ответвление В, филиал будет иметь приоритет и каждый раз status из говорит, что ветвления нет, ответвление В будет использоваться. Похоже, я был неправ, потому что когда status возврата филиала falseбольше никогда не вызывается.
Вот «минимальный пример«:

#include <gecode/minimodel.hh>
#include <iostream>

using namespace Gecode;
using namespace std;

class MyChoice : public Choice {
public:
int pos; // Position of the variable
int val; // Value of to assign

MyChoice(const Brancher& b, int pos0, int val0)
: Choice(b,2), pos(pos0), val(val0) {}

// Report size occupied
virtual size_t size(void) const {
return sizeof(*this);
}

// Archive into e
virtual void archive(Archive& e) const {
Choice::archive(e);
e << pos << val;
}
};

class BranchA : public Brancher {
protected:
ViewArray<Int::IntView> x;
public:
BranchA(Home home, ViewArray<Int::IntView>& x0)
: Brancher(home), x(x0) {}

static void post(Home home, ViewArray<Int::IntView>& x) {
(void) new (home) BranchA(home,x);
}

virtual size_t dispose(Space& home) {
(void) Brancher::dispose(home);
return sizeof(*this);
}
BranchA(Space& home, bool share, BranchA& b)
: Brancher(home,share,b) {
x.update(home,share,b.x);
}
virtual Brancher* copy(Space& home, bool share) {
return new (home) BranchA(home,share,*this);
}
// status
virtual bool status(const Space& home) const {
for (int i=0; i<x.size(); i++)
if (!x[i].assigned())
return !i%2 && x[i].in(1);
return false;
}
// choice
virtual Choice* choice(Space& home) {
for (int i=0; true; i++)
if (!x[i].assigned())
return new MyChoice(*this,i,1);
GECODE_NEVER;
return NULL;
}
virtual Choice* choice(const Space&, Archive& e) {
int pos, val;
e >> pos >> val;
return new MyChoice(*this, pos, val);
}
// commit
virtual ExecStatus commit(Space& home,
const Choice& c,
unsigned int a) {
const MyChoice& pv = static_cast<const MyChoice&>(c);
int pos=pv.pos, val=pv.val;
if (a == 0)
return me_failed(x[pos].eq(home,val)) ? ES_FAILED : ES_OK;
else
return me_failed(x[pos].nq(home,val)) ? ES_FAILED : ES_OK;
}
};
void branchA(Home home, const IntVarArgs& x) {
if (home.failed()) return;
ViewArray<Int::IntView> y(home,x);
BranchA::post(home,y);
}
// BranchB //////////////////////////////////////////////////////

class BranchB : public Brancher {
protected:
ViewArray<Int::IntView> x;
public:
BranchB(Home home, ViewArray<Int::IntView>& x0)
: Brancher(home), x(x0) {}
static void post(Home home, ViewArray<Int::IntView>& x) {
(void) new (home) BranchB(home,x);
}
virtual size_t dispose(Space& home) {
(void) Brancher::dispose(home);
return sizeof(*this);
}
BranchB(Space& home, bool share, BranchB& b)
: Brancher(home,share,b) {
x.update(home,share,b.x);
}
virtual Brancher* copy(Space& home, bool share) {
return new (home) BranchB(home,share,*this);
}
// status
virtual bool status(const Space& home) const {
for (int i=0; i<x.size(); i++)
if (!x[i].assigned())
return i%2 && x[i].in(2);
return false;
}
// choice
virtual Choice* choice(Space& home) {
for (int i=0; true; i++)
if (!x[i].assigned())
return new MyChoice(*this,i,2);
GECODE_NEVER;
return NULL;
}
virtual Choice* choice(const Space&, Archive& e) {
int pos, val;
e >> pos >> val;
return new MyChoice(*this, pos, val);
}
// commit
virtual ExecStatus commit(Space& home,
const Choice& c,
unsigned int a) {
const MyChoice& pv = static_cast<const MyChoice&>(c);
int pos=pv.pos, val=pv.val;
if (a == 0)
return me_failed(x[pos].eq(home,val)) ? ES_FAILED : ES_OK;
else
return me_failed(x[pos].nq(home,val)) ? ES_FAILED : ES_OK;
}
};
void branchB(Home home, const IntVarArgs& x) {
if (home.failed()) return;
ViewArray<Int::IntView> y(home,x);
BranchB::post(home,y);
}

// Minimal Space ///////////////////////////////////////class TestSpace : public Space {
protected:
IntVarArray x;
public:
TestSpace(int size)
: x(*this, size, 0, 10) {
branchA(*this, x);
branchB(*this, x);
}

TestSpace (bool share, TestSpace& s)
: Space(share, s) {
x.update(*this, share, s.x);
}

virtual Space* copy (bool share) {
return new TestSpace(share, *this);
}
void print(std::ostream& os) {
os << "x= " << x << endl;
}
};

// Minimal Main //////////////////////:

int main (int, char**) {
// create model and search engine
TestSpace* m = new TestSpace(10);
DFS<TestSpace> e(m);
delete m;
// search and print all solutions
while (TestSpace* s = e.next()) {
s->print(cout); delete s;
}
return 0;
}

В этом примере status ветвь вернуть true если следующая переменная для назначения находится на четное индекс, и если переменная может принимать значение 1 (false еще). И ответвление В status вернуть true если следующая переменная для назначения находится на странный индекс, и если переменная может принимать значение 2 (false еще).
С этим кодом я ожидал получить решения [1, 2, 1, 2, ...] а также [!1, !2, !1, !2, ...] (и другие комбинации, такие как [!1, 2, 1, !2, ...]) но так как филиалы располагаются, когда их status вернуть false, только две первые переменные были назначены.

Есть ли хороший способ сделать так, чтобы ветвь не утилизировалась после status вернуть false (или чередовать две разные стратегии ветвления) или я должен объединить два ответвления в один?