C++ SizeOptions类代码示例

  /// 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()); 

  }