/// Actual model GolombRuler(const SizeOptions& opt) : IntMinimizeScript(opt), m(*this,opt.size(),0, (opt.size() < 31) ? (1 << (opt.size()-1))-1 : Int::Limits::max) { // Assume first mark to be zero rel(*this, m[0], IRT_EQ, 0); // Order marks rel(*this, m, IRT_LE); // Number of marks and differences const int n = m.size(); const int n_d = (n*n-n)/2; // Array of differences IntVarArgs d(n_d); // Setup difference constraints for (int k=0, i=0; i<n-1; i++) for (int j=i+1; j<n; j++, k++) // d[k] is m[j]-m[i] and must be at least sum of first j-i integers rel(*this, d[k] = expr(*this, m[j]-m[i]), IRT_GQ, (j-i)*(j-i+1)/2); distinct(*this, d, opt.icl()); // Symmetry breaking if (n > 2) rel(*this, d[0], IRT_LE, d[n_d-1]); branch(*this, m, INT_VAR_NONE(), INT_VAL_MIN()); }
/// Actual model Photo(const SizeOptions& opt) : IntMinimizeScript(opt), spec(opt.size() == 0 ? p_small : p_large), pos(*this,spec.n_names, 0, spec.n_names-1), violations(*this,0,spec.n_prefs) { // Map preferences to violation BoolVarArgs viol(spec.n_prefs); for (int i=0; i<spec.n_prefs; i++) { int pa = spec.prefs[2*i+0]; int pb = spec.prefs[2*i+1]; viol[i] = expr(*this, abs(pos[pa]-pos[pb]) > 1); } rel(*this, violations == sum(viol)); distinct(*this, pos, opt.icl()); // Break some symmetries rel(*this, pos[0] < pos[1]); if (opt.branching() == BRANCH_NONE) { branch(*this, pos, INT_VAR_NONE(), INT_VAL_MIN()); } else { branch(*this, pos, tiebreak(INT_VAR_DEGREE_MAX(),INT_VAR_SIZE_MIN()), INT_VAL_MIN()); } }
Sudoku(const SizeOptions& opt) : x(*this, 9 * 9, 1, 9) { Matrix<IntVarArray> m(x, 9, 9); for (int i = 0; i < 9; i++) { distinct(*this, m.row(i), opt.icl()); distinct(*this, m.col(i), opt.icl()); } for (int i = 0; i < 9; i += 3) { for (int j = 0; j < 9; j += 3) { distinct(*this, m.slice(i, i + 3, j, j + 3), opt.icl()); } } for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { if (int v = sudokuField(board, i, j)) { //Here the m(i, j) is the element in colomn i and row j. rel(*this, m(i, j), IRT_EQ, v); } } } branch(*this, x, INT_VAR_NONE(), INT_VAL_SPLIT_MIN()); }
Coins3(const SizeOptions& opt) : num_coins_val(opt.size()), x(*this, n, 0, 99), num_coins(*this, 0, 99) { // values of the coins int _variables[] = {1, 2, 5, 10, 25, 50}; IntArgs variables(n, _variables); // sum the number of coins linear(*this, x, IRT_EQ, num_coins, opt.icl()); // This is the "main loop": // Checks that all changes from 1 to 99 can be made for(int j = 0; j < 99; j++) { IntVarArray tmp(*this, n, 0, 99); linear(*this, variables, tmp, IRT_EQ, j, opt.icl()); for(int i = 0; i < n; i++) { rel(*this, tmp[i] <= x[i], opt.icl()); } } // set the number of coins (via opt.size()) // don't forget // -search dfs if (num_coins_val) { rel(*this, num_coins == num_coins_val, opt.icl()); } branch(*this, x, INT_VAR_SIZE_MAX(), INT_VAL_MIN()); }
/// Constructor QueenArmies(const SizeOptions& opt) : n(opt.size()), U(*this, IntSet::empty, IntSet(0, n*n)), W(*this, IntSet::empty, IntSet(0, n*n)), w(*this, n*n, 0, 1), b(*this, n*n, 0, 1), q(*this, 0, n*n) { // Basic rules of the model for (int i = n*n; i--; ) { // w[i] means that no blacks are allowed on A[i] rel(*this, w[i] == (U || A[i])); // Make sure blacks and whites are disjoint. rel(*this, !w[i] || !b[i]); // If i in U, then b[i] has a piece. rel(*this, b[i] == (singleton(i) <= U)); } // Connect optimization variable to number of pieces linear(*this, w, IRT_EQ, q); linear(*this, b, IRT_GQ, q); // Connect cardinality of U to the number of black pieces. IntVar unknowns = expr(*this, cardinality(U)); rel(*this, q <= unknowns); linear(*this, b, IRT_EQ, unknowns); if (opt.branching() == BRANCH_NAIVE) { branch(*this, w, INT_VAR_NONE, INT_VAL_MAX); branch(*this, b, INT_VAR_NONE, INT_VAL_MAX); } else { QueenBranch::post(*this); assign(*this, b, INT_ASSIGN_MAX); } }
/// Actual model TSP(const SizeOptions& opt) : p(ps[opt.size()]), succ(*this, p.size(), 0, p.size()-1), total(*this, 0, p.max()) { int n = p.size(); // Cost matrix IntArgs c(n*n, p.d()); for (int i=n; i--; ) for (int j=n; j--; ) if (p.d(i,j) == 0) rel(*this, succ[i], IRT_NQ, j); // Cost of each edge IntVarArgs costs(*this, n, Int::Limits::min, Int::Limits::max); // Enforce that the succesors yield a tour with appropriate costs circuit(*this, c, succ, costs, total, opt.icl()); // Just assume that the circle starts forwards { IntVar p0(*this, 0, n-1); element(*this, succ, p0, 0); rel(*this, p0, IRT_LE, succ[0]); } // First enumerate cost values, prefer those that maximize cost reduction branch(*this, costs, INT_VAR_REGRET_MAX_MAX(), INT_VAL_SPLIT_MIN()); // Then fix the remaining successors branch(*this, succ, INT_VAR_MIN_MIN(), INT_VAL_MIN()); }
SetCovering(const SizeOptions& opt) : x(*this, num_alternatives, 0, 1), z(*this, 0, 999999) { // costs per alternative int _costs[] = {19, 16, 18, 13, 15, 19, 15, 17, 16, 15}; IntArgs costs(num_alternatives, _costs); // the alternatives and the objects they contain int _a[] = { // 1 2 3 4 5 6 7 8 the objects 1,0,0,0,0,1,0,0, // alternative 1 0,1,0,0,0,1,0,1, // alternative 2 1,0,0,1,0,0,1,0, // alternative 3 0,1,1,0,1,0,0,0, // alternative 4 0,1,0,0,1,0,0,0, // alternative 5 0,1,1,0,0,0,0,0, // alternative 6 0,1,1,1,0,0,0,0, // alternative 7 0,0,0,1,1,0,0,1, // alternative 8 0,0,1,0,0,1,0,1, // alternative 9 1,0,0,0,0,1,1,0, // alternative 10 }; IntArgs a(num_alternatives*num_objects, _a); for(int j = 0; j < num_objects; j++) { IntVarArgs tmp; for(int i = 0; i < num_alternatives; i++) { tmp << expr(*this, x[i]*a[i*num_objects+j]); } if (opt.size() == 0) { // set partition problem: // objects must be covered _exactly_ once rel(*this, sum(tmp) == 1); } else { // set covering problem // all objects must be covered _at least_ once rel(*this, sum(tmp) >= 1); } } if (opt.search() == SEARCH_DFS) { if (opt.size() == 0) { rel(*this, z <= 49); } else { rel(*this, z <= 45); } } linear(*this, costs, x, IRT_EQ, z); branch(*this, x, INT_VAR_NONE(), INT_VAL_MIN()); }
/// The actual problem OpenShop(const SizeOptions& opt) : spec(examples[opt.size()]), b(*this, (spec.n+spec.m-2)*spec.n*spec.m/2, 0,1), makespan(*this, 0, Int::Limits::max), _start(*this, spec.m*spec.n, 0, Int::Limits::max) { Matrix<IntVarArray> start(_start, spec.m, spec.n); IntArgs _dur(spec.m*spec.n, spec.p); Matrix<IntArgs> dur(_dur, spec.m, spec.n); int minmakespan; int maxmakespan; crosh(dur, minmakespan, maxmakespan); rel(*this, makespan <= maxmakespan); rel(*this, makespan >= minmakespan); int k=0; for (int m=0; m<spec.m; m++) for (int j0=0; j0<spec.n-1; j0++) for (int j1=j0+1; j1<spec.n; j1++) { // The tasks on machine m of jobs j0 and j1 must be disjoint rel(*this, b[k] == (start(m,j0) + dur(m,j0) <= start(m,j1))); rel(*this, b[k++] == (start(m,j1) + dur(m,j1) > start(m,j0))); } for (int j=0; j<spec.n; j++) for (int m0=0; m0<spec.m-1; m0++) for (int m1=m0+1; m1<spec.m; m1++) { // The tasks in job j on machine m0 and m1 must be disjoint rel(*this, b[k] == (start(m0,j) + dur(m0,j) <= start(m1,j))); rel(*this, b[k++] == (start(m1,j) + dur(m1,j) > start(m0,j))); } // The makespan is greater than the end time of the latest job for (int m=0; m<spec.m; m++) { for (int j=0; j<spec.n; j++) { rel(*this, start(m,j) + dur(m,j) <= makespan); } } // First branch over the precedences branch(*this, b, INT_VAR_AFC_MAX(opt.decay()), INT_VAL_MAX()); // When the precedences are fixed, simply assign the start times assign(*this, _start, INT_ASSIGN_MIN()); // When the start times are fixed, use the tightest makespan assign(*this, makespan, INT_ASSIGN_MIN()); }
/// Post a distinct-linear constraint on variables \a x with sum \a c void distinctlinear(Cache& dc, const IntVarArgs& x, int c, const SizeOptions& opt) { int n=x.size(); if (opt.model() == MODEL_DECOMPOSE) { if (n < 8) linear(*this, x, IRT_EQ, c, opt.icl()); else if (n == 8) rel(*this, x, IRT_NQ, 9*(9+1)/2 - c); distinct(*this, x, opt.icl()); } else { switch (n) { case 0: return; case 1: rel(*this, x[0], IRT_EQ, c); return; case 8: // Prune the single missing digit rel(*this, x, IRT_NQ, 9*(9+1)/2 - c); break; case 9: break; default: if (c == n*(n+1)/2) { // sum has unique decomposition: 1 + ... + n rel(*this, x, IRT_LQ, n); } else if (c == n*(n+1)/2 + 1) { // sum has unique decomposition: 1 + ... + n-1 + n+1 rel(*this, x, IRT_LQ, n+1); rel(*this, x, IRT_NQ, n); } else if (c == 9*(9+1)/2 - (9-n)*(9-n+1)/2) { // sum has unique decomposition: (9-n+1) + (9-n+2) + ... + 9 rel(*this, x, IRT_GQ, 9-n+1); } else if (c == 9*(9+1)/2 - (9-n)*(9-n+1)/2 + 1) { // sum has unique decomposition: (9-n) + (9-n+2) + ... + 9 rel(*this, x, IRT_GQ, 9-n); rel(*this, x, IRT_NQ, 9-n+1); } else { extensional(*this, x, dc.get(n,c)); return; } } distinct(*this, x, opt.icl()); } }
/// Actual model AllInterval(const SizeOptions& opt) : x(*this, opt.size(), 0, opt.size()-1), d(*this, opt.size()-1, 1, opt.size()-1) { const int n = x.size(); // Set up variables for distance for (int i=0; i<n-1; i++) rel(*this, d[i] == abs(x[i+1]-x[i]), opt.icl()); distinct(*this, x, opt.icl()); distinct(*this, d, opt.icl()); // Break mirror symmetry rel(*this, x[0], IRT_LE, x[1]); // Break symmetry of dual solution rel(*this, d[0], IRT_GR, d[n-2]); branch(*this, x, INT_VAR_SIZE_MIN(), INT_VAL_SPLIT_MIN()); }
// Actual model AllEqual(const SizeOptions& opt) : x(*this, n, 0, 6) { all_equal(*this, x, n, opt.icl()); // branching branch(*this, x, INT_VAR_SIZE_MIN(), INT_VAL_MIN()); }
LatinSquares(const SizeOptions& opt) : n(opt.size()), x(*this, n*n, 1, n) { // Matrix wrapper for the x grid Matrix<IntVarArray> m(x, n, n); latin_square(*this, m, opt.icl()); // Symmetry breaking. 0 is upper left column if (opt.symmetry() == SYMMETRY_MIN) { rel(*this, x[0] == 1, opt.icl()); } branch(*this, x, INT_VAR_SIZE_MIN(), INT_VAL_RANGE_MAX()); }
/// Actual model WordSquare(const SizeOptions& opt) : w_l(opt.size()), letters(*this, w_l*w_l) { // Initialize letters Matrix<IntVarArray> ml(letters, w_l, w_l); for (int i=0; i<w_l; i++) for (int j=i; j<w_l; j++) ml(i,j) = ml(j,i) = IntVar(*this, 'a','z'); // Number of words with that length const int n_w = dict.words(w_l); // Initialize word array IntVarArgs words(*this, w_l, 0, n_w-1); // All words must be different distinct(*this, words); // Link words with letters for (int i=0; i<w_l; i++) { // Map each word to i-th letter in that word IntSharedArray w2l(n_w); for (int n=n_w; n--; ) w2l[n]=dict.word(w_l,n)[i]; for (int j=0; j<w_l; j++) element(*this, w2l, words[j], ml(i,j)); } // Symmetry breaking: the last word must be later in the wordlist rel(*this, words[0], IRT_LE, words[w_l-1]); switch (opt.branching()) { case BRANCH_WORDS: // Branch by assigning words branch(*this, words, INT_VAR_SIZE_MIN(), INT_VAL_SPLIT_MIN()); break; case BRANCH_LETTERS: // Branch by assigning letters branch(*this, letters, INT_VAR_AFC_SIZE_MAX(opt.decay()), INT_VAL_MIN()); break; } }
/// Actual model Partition(const SizeOptions& opt) : x(*this,opt.size(),1,2*opt.size()), y(*this,opt.size(),1,2*opt.size()) { const int n = opt.size(); // Break symmetries by ordering numbers in each group rel(*this, x, IRT_LE); rel(*this, y, IRT_LE); rel(*this, x[0], IRT_LE, y[0]); IntVarArgs xy(2*n); for (int i = n; i--; ) { xy[i] = x[i]; xy[n+i] = y[i]; } distinct(*this, xy, opt.icl()); IntArgs c(2*n); for (int i = n; i--; ) { c[i] = 1; c[n+i] = -1; } linear(*this, c, xy, IRT_EQ, 0); // Array of products IntVarArgs sxy(2*n), sx(n), sy(n); for (int i = n; i--; ) { sx[i] = sxy[i] = expr(*this, sqr(x[i])); sy[i] = sxy[n+i] = expr(*this, sqr(y[i])); } linear(*this, c, sxy, IRT_EQ, 0); // Redundant constraints linear(*this, x, IRT_EQ, 2*n*(2*n+1)/4); linear(*this, y, IRT_EQ, 2*n*(2*n+1)/4); linear(*this, sx, IRT_EQ, 2*n*(2*n+1)*(4*n+1)/12); linear(*this, sy, IRT_EQ, 2*n*(2*n+1)*(4*n+1)/12); branch(*this, xy, INT_VAR_AFC_SIZE_MAX(opt.decay()), INT_VAL_MIN()); }
SetCovering(const SizeOptions& opt) : min_distance(opt.size()), x(*this, num_cities, 0, 1), z(*this, 0, num_cities) { // distance between the cities int distance[] = { 0,10,20,30,30,20, 10, 0,25,35,20,10, 20,25, 0,15,30,20, 30,35,15, 0,15,25, 30,20,30,15, 0,14, 20,10,20,25,14, 0 }; // z = sum of placed fire stations linear(*this, x, IRT_EQ, z, opt.icl()); // ensure that all cities are covered by at least one fire station for(int i = 0; i < num_cities; i++) { IntArgs in_distance(num_cities); // the cities within the distance for(int j = 0; j < num_cities; j++) { if (distance[i*num_cities+j] <= min_distance) { in_distance[j] = 1; } else { in_distance[j] = 0; } } linear(*this, in_distance, x, IRT_GQ, 1, opt.icl()); } branch(*this, x, INT_VAR_SIZE_MAX(), INT_VAL_SPLIT_MIN()); }
/// The actual model GraphColor(const SizeOptions& opt) : g(opt.size() == 1 ? g2 : g1), v(*this,g.n_v,0,g.n_v), m(*this,0,g.n_v) { rel(*this, v, IRT_LQ, m); for (int i = 0; g.e[i] != -1; i += 2) rel(*this, v[g.e[i]], IRT_NQ, v[g.e[i+1]]); const int* c = g.c; for (int i = *c++; i--; c++) rel(*this, v[*c], IRT_EQ, i); while (*c != -1) { int n = *c; IntVarArgs x(n); c++; for (int i = n; i--; c++) x[i] = v[*c]; distinct(*this, x, opt.icl()); if (opt.model() == MODEL_CLIQUE) rel(*this, m, IRT_GQ, n-1); } branch(*this, m, INT_VAL_MIN); switch (opt.branching()) { case BRANCH_SIZE: branch(*this, v, INT_VAR_SIZE_MIN, INT_VAL_MIN); break; case BRANCH_DEGREE: branch(*this, v, tiebreak(INT_VAR_DEGREE_MAX,INT_VAR_SIZE_MIN), INT_VAL_MIN); break; case BRANCH_SIZE_DEGREE: branch(*this, v, INT_VAR_SIZE_DEGREE_MIN, INT_VAL_MIN); break; case BRANCH_SIZE_AFC: branch(*this, v, INT_VAR_SIZE_AFC_MIN, INT_VAL_MIN); break; default: break; } }
/// The actual problem Kakuro(const SizeOptions& opt) : w(examples[opt.size()][0]), h(examples[opt.size()][1]), f(*this,w*h) { IntVar black(*this,0,0); // Initialize all fields as black (unused). Only if a field // is actually used in a constraint, create a fresh variable // for it (done via init). for (int i=w*h; i--; ) f[i] = black; // Cache of already computed tuple sets Cache cache; // Matrix for accessing board fields Matrix<IntVarArray> b(f,w,h); // Access to hints const int* k = &examples[opt.size()][2]; // Process vertical hints while (*k >= 0) { int x=*k++; int y=*k++; int n=*k++; int s=*k++; IntVarArgs col(n); for (int i=n; i--; ) col[i]=init(b(x,y+i+1)); distinctlinear(cache,col,s,opt); } k++; // Process horizontal hints while (*k >= 0) { int x=*k++; int y=*k++; int n=*k++; int s=*k++; IntVarArgs row(n); for (int i=n; i--; ) row[i]=init(b(x+i+1,y)); distinctlinear(cache,row,s,opt); } branch(*this, f, INT_VAR_AFC_SIZE_MAX(opt.decay()), INT_VAL_SPLIT_MIN()); }
/// Actual model AllInterval(const SizeOptions& opt) : x(*this, opt.size(), 0, opt.size() - 1) { const int n = x.size(); IntVarArgs d(n-1); // Set up variables for distance for (int i=0; i<n-1; i++) d[i] = expr(*this, abs(x[i+1]-x[i]), opt.icl()); // Constrain them to be between 1 and n-1 dom(*this, d, 1, n-1); distinct(*this, x, opt.icl()); distinct(*this, d, opt.icl()); // Break mirror symmetry rel(*this, x[0], IRT_LE, x[1]); // Break symmetry of dual solution rel(*this, d[0], IRT_GR, d[n-2]); branch(*this, x, INT_VAR_SIZE_MIN, INT_VAL_SPLIT_MIN); }
/// Post constraints MagicSquare(const SizeOptions& opt) : n(opt.size()), x(*this,n*n,1,n*n) { // Number of fields on square const int nn = n*n; // Sum of all a row, column, or diagonal const int s = nn*(nn+1) / (2*n); // Matrix-wrapper for the square Matrix<IntVarArray> m(x, n, n); for (int i = n; i--; ) { linear(*this, m.row(i), IRT_EQ, s, opt.icl()); linear(*this, m.col(i), IRT_EQ, s, opt.icl()); } // Both diagonals must have sum s { IntVarArgs d1y(n); IntVarArgs d2y(n); for (int i = n; i--; ) { d1y[i] = m(i,i); d2y[i] = m(n-i-1,i); } linear(*this, d1y, IRT_EQ, s, opt.icl()); linear(*this, d2y, IRT_EQ, s, opt.icl()); } // All fields must be distinct distinct(*this, x, opt.icl()); // Break some (few) symmetries rel(*this, m(0,0), IRT_GR, m(0,n-1)); rel(*this, m(0,0), IRT_GR, m(n-1,0)); branch(*this, x, INT_VAR_SIZE_MIN, INT_VAL_SPLIT_MIN); }
/// Actual model OrthoLatinSquare(const SizeOptions& opt) : Script(opt), n(opt.size()), x1(*this,n*n,1,n), x2(*this,n*n,1,n) { const int nn = n*n; IntVarArgs z(*this,nn,0,n*n-1); distinct(*this, z, opt.icl()); // Connect { IntArgs mod(n*n); IntArgs div(n*n); for (int i=0; i<n; i++) for (int j=0; j<n; j++) { mod[i*n+j] = j+1; div[i*n+j] = i+1; } for (int i = nn; i--; ) { element(*this, div, z[i], x2[i]); element(*this, mod, z[i], x1[i]); } } // Rows for (int i = n; i--; ) { IntVarArgs ry(n); for (int j = n; j--; ) ry[j] = y1(i,j); distinct(*this, ry, opt.icl()); for (int j = n; j--; ) ry[j] = y2(i,j); distinct(*this, ry, opt.icl()); } for (int j = n; j--; ) { IntVarArgs cy(n); for (int i = n; i--; ) cy[i] = y1(i,j); distinct(*this, cy, opt.icl()); for (int i = n; i--; ) cy[i] = y2(i,j); distinct(*this, cy, opt.icl()); } for (int i = 1; i<n; i++) { IntVarArgs ry1(n); IntVarArgs ry2(n); for (int j = n; j--; ) { ry1[j] = y1(i-1,j); ry2[j] = y2(i,j); } rel(*this, ry1, IRT_GQ, ry2); } branch(*this, z, INT_VAR_SIZE_MIN(), INT_VAL_SPLIT_MIN()); }
// Actual model AlldifferentCst(const SizeOptions& opt) : x(*this, n, 1, 9), cst(*this, n, 0, 9) { int _cst1[] = {0,1,0,4}; IntArgs cst1(n, _cst1); for(int i = 0; i < n; i++) { rel(*this, cst[i] == cst1[i]); } alldifferent_cst(*this, x, cst, n, opt.icl()); // branching branch(*this, x, INT_VAR_SIZE_MIN(), INT_VAL_MIN()); }
/// The actual problem Queens(const SizeOptions& opt) : q(*this,opt.size(),0,opt.size()-1) { const int n = q.size(); switch (opt.propagation()) { case PROP_BINARY: for (int i = 0; i<n; i++) for (int j = i+1; j<n; j++) { rel(*this, q[i] != q[j]); rel(*this, q[i]+i != q[j]+j); rel(*this, q[i]-i != q[j]-j); } break; case PROP_MIXED: for (int i = 0; i<n; i++) for (int j = i+1; j<n; j++) { rel(*this, q[i]+i != q[j]+j); rel(*this, q[i]-i != q[j]-j); } distinct(*this, q, opt.icl()); break; case PROP_DISTINCT: distinct(*this, IntArgs::create(n,0,1), q, opt.icl()); distinct(*this, IntArgs::create(n,0,-1), q, opt.icl()); distinct(*this, q, opt.icl()); break; } switch(opt.branching()) { case BRANCH_MIN: branch(*this, q, INT_VAR_SIZE_MIN(), INT_VAL_MIN()); break; case BRANCH_MID: branch(*this, q, INT_VAR_SIZE_MIN(), INT_VAL_MIN()); break; case BRANCH_MAX_MAX: branch(*this, q, INT_VAR_SIZE_MAX(), INT_VAL_MIN()); break; case BRANCH_KNIGHT_MOVE: branch(*this, q, INT_VAR_MIN_MIN(), INT_VAL_MED()); break; } }
// Actual model AlldifferentModulo(const SizeOptions& opt) : x(*this, n, 1, 25), m(*this, 1, 5) { int _tmp[] = {25,1,14,3}; IntArgs tmp(n, _tmp); for(int i = 0; i < n; i++) { rel(*this, x[i] == tmp[i]); } alldifferent_modulo(*this, x, n, m, opt.icl()); // rel(*this, m==5); // branching branch(*this, x, INT_VAR_SIZE_MIN(), INT_VAL_MIN()); branch(*this, m, INT_VAL_MIN()); }
/// Actual model MineSweeper(const SizeOptions& opt) : spec(specs[opt.size()]), size(spec_size(spec)), b(*this,size*size,0,1) { Matrix<BoolVarArray> m(b, size, size); // Initialize matrix and post constraints for (int h=0; h<size; h++) for (int w=0; w<size; w++) { int v = mineField(spec, size, h, w); if (v != -1) { rel(*this, m(w, h), IRT_EQ, 0); linear(*this, fieldsAround(m, w, h), IRT_EQ, v); } } // Install branching branch(*this, b, INT_VAR_NONE(), INT_VAL_MAX()); }
/// The actual problem DominatingQueens(const SizeOptions& opt) : IntMinimizeScript(opt), n(opt.size()), b(*this,n*n,0,n*n-1), q(*this,1,n) { // Constrain field to the fields that can attack a field for (int i=0; i<n*n; i++) dom(*this, b[i], attacked(i)); // At most q queens can be placed nvalues(*this, b, IRT_LQ, q); /* * According to: P. R. J. Östergard and W. D. Weakley, Values * of Domination Numbers of the Queen's Graph, Electronic Journal * of Combinatorics, 8:1-19, 2001, for n <= 120, the minimal number * of queens is either ceil(n/2) or ceil(n/2 + 1). */ if (n <= 120) dom(*this, q, (n+1)/2, (n+1)/2 + 1); branch(*this, b, INT_VAR_SIZE_MIN(), INT_VAL_MIN()); // Try the easier solution first branch(*this, q, INT_VAL_MAX()); }
// Actual model AlldifferentOnIntersection(const SizeOptions& opt) : x(*this, m, 1, 9), y(*this, n, 1, 9) { int _xtmp[] = {5,9,1,5}; IntArgs xtmp(m, _xtmp); for(int i = 0; i < m; i++) { rel(*this, x[i] == xtmp[i]); } int _ytmp[] = {2, 1, 6, 9, 6, 2}; IntArgs ytmp(n, _ytmp); for(int j = 0; j < n; j++) { rel(*this, y[j] == ytmp[j]); } alldifferent_on_intersection(*this, x, m, y, n, opt.icl()); // branching branch(*this, x, INT_VAR_SIZE_MIN(), INT_VAL_MIN()); branch(*this, y, INT_VAR_SIZE_MIN(), INT_VAL_MIN()); }
SUSHI_EQUATION(const SizeOptions& opt) : n_x(*this, 1, wordlength), n_y(*this, 1, wordlength), n_z(*this, 1, wordlength), n_t(*this, opt.size()+1, opt.size()+1), X(*this, wordlength , val_dom_min, val_dom_max), Y(*this, wordlength , val_dom_min, val_dom_max), Z(*this, wordlength , val_dom_min, val_dom_max), T(*this, opt.size()+1 , val_dom_min, val_dom_max){ int n = opt.size(); gecode_find_solution = false; REG r_a(1); REG r_b(2); REG dum(dummy_sym); REG reg_z = r_b(n,n) + r_a + r_b(n,n); if (opt.propagation() == PROP_PAD) { reg_z += (*dum); } DFA myDFA_z(reg_z); // T = "a" . Y[0,n] rel(*this, T[0]==1); for (int i = 0; (i < n) && (i+1 < T.size()); i++){ T[i+1] = Y[i]; } rel(*this, n_y >= n); switch(opt.propagation()){ case PROP_OPEN: extensional(*this, Z, myDFA_z, n_z); //concat(*this, X, n_x, T, n_t, Z, n_z, ICL_BND); rel(*this, n_z == (n_x+n_t)); for(int i=0; i<wordlength; i++) { rel(*this, (i<n_x) >> (X[i]==Z[i])); BoolVar b = expr(*this, i==n_x); for(int j=0; (i+j)<wordlength; j++) { rel(*this, (b&&(j<n_t)) >> (T[j]==Z[i+j])); } } break; case PROP_CLOSED: extensional(*this, Z, myDFA_z); rel(*this, n_z == (n_x+n_t)); rel(*this, n_y == wordlength); for(int i=0; i<wordlength; i++) { rel(*this, (i<n_x) >> (X[i]==Z[i])); BoolVar b = expr(*this, i==n_x); for(int j=0; (j < T.size()) && ((i+j)<wordlength); j++) { rel(*this, (b&&(j<n_t)) >> (T[j]==Z[i+j])); } } break; case PROP_PAD: extensional(*this, Z, myDFA_z); for(int i=0; i<wordlength; i++) { rel(*this, (Z[i]==dummy_sym) == (n_z<=i)); rel(*this, (Y[i]==dummy_sym) == (n_y<=i)); rel(*this, (X[i]==dummy_sym) == (n_x<=i)); } rel(*this, n_z == (n_x+n_t)); for(int i=0; i<wordlength; i++) { rel(*this, (i<n_x) >> (X[i]==Z[i])); BoolVar b = expr(*this, i==n_x); for(int j=0; (j < T.size()) && ((i+j)<wordlength); j++) { rel(*this, (b&&(j<n_t)) >> (T[j]==Z[i+j])); } } break; } IntVarArgs lengths; lengths << n_z << n_x << n_y; switch(opt.branching()){ case BRANCH_N_A: branch(*this, lengths, INT_VAR_SIZE_MIN(), INT_VAL_MIN()); branch(*this, Z, INT_VAR_SIZE_MIN(), INT_VAL_MIN()); branch(*this, X, INT_VAR_SIZE_MIN(), INT_VAL_MIN()); branch(*this, Y, INT_VAR_SIZE_MIN(), INT_VAL_MIN()); break; case BRANCH_A_N: branch(*this, Z, INT_VAR_SIZE_MIN(), INT_VAL_MIN()); branch(*this, X, INT_VAR_SIZE_MIN(), INT_VAL_MIN()); branch(*this, Y, INT_VAR_SIZE_MIN(), INT_VAL_MIN()); branch(*this, lengths, INT_VAR_SIZE_MIN(), INT_VAL_MIN()); break; case BRANCH_BOUND: boundednone(*this, Z, n_z); boundednone(*this, X, n_x); boundednone(*this, Y, n_y); break; } }
/// Actual model AllInterval(const SizeOptions& opt) : Script(opt), x(*this, opt.size(), 0, 66) { // 66 or opt.size() - 1 const int n = x.size(); IntVarArgs d(n-1); IntVarArgs dd(66); IntVarArgs xx_(n); // pitch class for AllInterval Chords IntVar douze; Rnd r(1U); if ((opt.model() == MODEL_SET) || (opt.model() == MODEL_SET_CHORD) || (opt.model() == MODEL_SSET_CHORD) ||(opt.model() == MODEL_SYMMETRIC_SET)) // Modele original : serie { // Set up variables for distance for (int i=0; i<n-1; i++) d[i] = expr(*this, abs(x[i+1]-x[i]), opt.ipl()); // Constrain them to be between 1 and n-1 dom(*this, d, 1, n-1); dom(*this, x, 0, n-1); if((opt.model() == MODEL_SET_CHORD) || (opt.model() == MODEL_SSET_CHORD)) { /*expr(*this,dd[0]==0); // Set up variables for distance for (int i=0; i<n-1; i++) { expr(*this, dd[i+1] == (dd[i]+d[i])%12, opt.icl()); } // Constrain them to be between 1 and n-1 dom(*this, dd,0, n-1); distinct(*this, dd, opt.icl()); */ rel(*this, abs(x[0]-x[n-1]) == 6, opt.ipl()); } if(opt.symmetry()) { // Break mirror symmetry (renversement) rel(*this, x[0], IRT_LE, x[1]); // Break symmetry of dual solution (retrograde de la serie) -> 1928 solutions pour accords de 12 sons rel(*this, d[0], IRT_GR, d[n-2]); } //series symetriques if ((opt.model() == MODEL_SYMMETRIC_SET)|| (opt.model() == MODEL_SSET_CHORD)) { rel (*this, d[n/2 - 1] == 6); // pivot = triton for (int i=0; i<(n/2)-2; i++) rel(*this,d[i]+d[n-i-2]==12); } } else { for (int j=0; j<n; j++) xx_[j] = expr(*this, x[j] % 12); dom(*this, xx_, 0, 11); distinct(*this, xx_, opt.ipl()); //intervalles for (int i=0; i<n-1; i++) d[i] = expr(*this,x[i+1] - x[i],opt.ipl()); dom(*this, d, 1, n-1); dom(*this, x, 0, n * (n - 1) / 2.); //d'autres choses dont on est certain (contraintes redondantes) : rel(*this, x[0] == 0); rel(*this, x[n-1] == n * (n - 1) / 2.); // break symmetry of dual solution (renversement de l'accord) if(opt.symmetry()) rel(*this, d[0], IRT_GR, d[n-2]); //accords symetriques if (opt.model() == MODEL_SYMMETRIC_CHORD) { rel (*this, d[n/2 - 1] == 6); // pivot = triton for (int i=0; i<(n/2)-2; i++) rel(*this,d[i]+d[n-i-2]==12); } if (opt.model() == MODEL_PARALLEL_CHORD) { rel (*this, d[n/2 - 1] == 6); // pivot = triton for (int i=0; i<(n/2)-2; i++) rel(*this,d[i]+d[n/2 + i]==12); } } distinct(*this, x, opt.ipl()); distinct(*this, d, opt.ipl()); #if 0 //TEST IntVarArray counter(*this,12,0,250); IntVar testcounter(*this,0,250); for (int i=1; i<11; i++) { count(*this, d, i,IRT_EQ,testcounter,opt.icl()); // OK } count(*this, d, counter,opt.icl()); // OK #endif //END TEST if(opt.branching() == 0) branch(*this, x, INT_VAR_SIZE_MIN(), INT_VAL_SPLIT_MIN()); else branch(*this, x, INT_VAR_RND(r), INT_VAL_RND(r)); }
// Actual model Speakers(const SizeOptions& opt) : x(*this, n, 1, n) { // // available slots: // /* // First solution: populate from a integer array // where the first number represents the number of items int __available[] = { // size: available // Reasoning. Step# : reason 4, 3,4,5,6, // #2: the only one with 6 after speaker F -> 1 2, 3,4, // #5: 3 or 4 4, 2,3,4,5, // #3: only with 5 after F -> 1 and A -> 6 3, 2,3,4, // #4: only with 2 after C -> 5 and F -> 1 2, 3,4, // #5: 3 or 4 6, 1,2,3,4,5,6 // #1: the only with 1 }; // convert to IntSet IntSet _available[n]; int s = 0; for(int i = 0; i < n; i++) { int num = __available[s++]; IntArgs tmp; for(int j = 0; j < num; j++) { tmp << __available[s++]; } _available[i] = IntSet(tmp); } // and then to IntSetArgs IntSetArgs available(n, _available); */ // // Oh, this is much easier, at least for this small example // IntSetArgs available(n); available[0] = IntSet( IntArgs() << 3 << 4 << 5 << 6 ); available[1] = IntSet( IntArgs() << 3 << 4 ); available[2] = IntSet( IntArgs() << 2 << 3 << 4 << 5 ); available[3] = IntSet( IntArgs() << 2 << 3 << 4 ); available[4] = IntSet( IntArgs() << 3 << 4 ); available[5] = IntSet( IntArgs() << 1 << 2 << 3 << 4 << 5 << 6 ); distinct(*this, x, opt.icl()); for(int i = 0; i < n; i++) { // From Modeling and Programming in Gecode, // section 5.2.2, Relation constraints: // """ // If x is a set variable and y is an integer variable, then // rel(home, x, SRT_SUP, y); // constrains x to be a superset of the singleton set {y}, // which means that y must be an element of x. // """ // // corresponds to: forall(i in 1..n) (x[i] in available[i]) // // rel(*this, SetVar(*this, available[i],available[i]), SRT_SUP, x[i]); // this is easier: rel(*this, singleton(x[i]) <= available[i]); } branch(*this, x, INT_VAR_SIZE_MIN(), INT_VAL_MIN()); }
/// The actual model GraphColor(const SizeOptions& opt) : IntMinimizeScript(opt), g(opt.size() == 1 ? g2 : g1), v(*this,g.n_v,0,g.n_v-1), m(*this,0,g.n_v-1) { rel(*this, v, IRT_LQ, m); for (int i = 0; g.e[i] != -1; i += 2) rel(*this, v[g.e[i]], IRT_NQ, v[g.e[i+1]]); const int* c = g.c; for (int i = *c++; i--; c++) rel(*this, v[*c], IRT_EQ, i); while (*c != -1) { int n = *c; IntVarArgs x(n); c++; for (int i = n; i--; c++) x[i] = v[*c]; distinct(*this, x, opt.icl()); if (opt.model() == MODEL_CLIQUE) rel(*this, m, IRT_GQ, n-1); } /// Branching on the number of colors branch(*this, m, INT_VAL_MIN()); if (opt.symmetry() == SYMMETRY_NONE) { /// Branching without symmetry breaking switch (opt.branching()) { case BRANCH_SIZE: branch(*this, v, INT_VAR_SIZE_MIN(), INT_VAL_MIN()); break; case BRANCH_DEGREE: branch(*this, v, tiebreak(INT_VAR_DEGREE_MAX(),INT_VAR_SIZE_MIN()), INT_VAL_MIN()); break; case BRANCH_SIZE_DEGREE: branch(*this, v, INT_VAR_DEGREE_SIZE_MAX(), INT_VAL_MIN()); break; case BRANCH_SIZE_AFC: branch(*this, v, INT_VAR_AFC_SIZE_MAX(opt.decay()), INT_VAL_MIN()); break; case BRANCH_SIZE_ACTIVITY: branch(*this, v, INT_VAR_ACTIVITY_SIZE_MAX(opt.decay()), INT_VAL_MIN()); break; default: break; } } else { // opt.symmetry() == SYMMETRY_LDSB /// Branching while considering value symmetry breaking /// (every permutation of color values gives equivalent solutions) Symmetries syms; syms << ValueSymmetry(IntArgs::create(g.n_v,0)); switch (opt.branching()) { case BRANCH_SIZE: branch(*this, v, INT_VAR_SIZE_MIN(), INT_VAL_MIN(), syms); break; case BRANCH_DEGREE: branch(*this, v, tiebreak(INT_VAR_DEGREE_MAX(),INT_VAR_SIZE_MIN()), INT_VAL_MIN(), syms); break; case BRANCH_SIZE_DEGREE: branch(*this, v, INT_VAR_DEGREE_SIZE_MAX(), INT_VAL_MIN(), syms); break; case BRANCH_SIZE_AFC: branch(*this, v, INT_VAR_AFC_SIZE_MAX(opt.decay()), INT_VAL_MIN(), syms); break; case BRANCH_SIZE_ACTIVITY: branch(*this, v, INT_VAR_ACTIVITY_SIZE_MAX(opt.decay()), INT_VAL_MIN(), syms); break; default: break; } } }