/**
  * Creates a directed tree constraint : g forms an arborescence rooted in vertex 'root' i.e. g has
  * no circuit and a path exists from the root to every node
  *
  * @param g a directed graph variable
  * @param root the (fixed) root of the tree
  * @return a directed tree constraint
  */
 public static Constraint directed_tree(IDirectedGraphVar g, int root) {
   int n = g.getNbMaxNodes();
   int[] nbPreds = new int[n];
   for (int i = 0; i < n; i++) {
     nbPreds[i] = 1;
   }
   nbPreds[root] = 0;
   return new Constraint(
       "directed_tree",
       new PropArborescence(g, root),
       new PropNodeDegree_AtMost_Coarse(g, Orientation.PREDECESSORS, nbPreds),
       new PropNodeDegree_AtLeast_Incr(g, Orientation.PREDECESSORS, nbPreds));
 }
 /**
  * g must form a circuit
  *
  * @param g a directed graph variable
  * @return a circuit constraint
  */
 public static Constraint circuit(IDirectedGraphVar g) {
   if (g.getMandatoryNodes().getSize() == g.getNbMaxNodes()) {
     return hamiltonian_circuit(g);
   }
   return new Constraint(
       "circuit",
       new PropNodeDegree_AtLeast_Incr(g, Orientation.SUCCESSORS, 1),
       new PropNodeDegree_AtLeast_Incr(g, Orientation.PREDECESSORS, 1),
       new PropNodeDegree_AtMost_Incr(g, Orientation.SUCCESSORS, 1),
       new PropNodeDegree_AtMost_Incr(g, Orientation.PREDECESSORS, 1),
       new PropNbSCC(g, g.getSolver().ONE),
       new PropCircuit(g));
 }
 /**
  * Creates a path constraint : g forms a path from node 'from' to node 'to' Basic but fast
  * propagation
  *
  * @param g a directed graph variable
  * @param from an integer variable
  * @param to an integer variable
  * @return a path constraint
  */
 public static Constraint path(IDirectedGraphVar g, int from, int to) {
   int n = g.getNbMaxNodes();
   int[] succs = new int[n];
   int[] preds = new int[n];
   for (int i = 0; i < n; i++) {
     succs[i] = preds[i] = 1;
   }
   succs[to] = preds[from] = 0;
   Propagator[] props =
       new Propagator[] {
         new PropNodeDegree_AtLeast_Coarse(g, Orientation.SUCCESSORS, succs),
         new PropNodeDegree_AtMost_Incr(g, Orientation.SUCCESSORS, succs),
         new PropNodeDegree_AtLeast_Coarse(g, Orientation.PREDECESSORS, preds),
         new PropNodeDegree_AtMost_Incr(g, Orientation.PREDECESSORS, preds),
         new PropPathNoCircuit(g)
       };
   return new Constraint("path", props);
 }
 /**
  * Creates a strong connectedness constraint which ensures that g is strongly connected
  *
  * @param g a directed graph variable
  * @return A strong connectedness constraint which ensures that g is strongly connected
  */
 public static Constraint strongly_connected(IDirectedGraphVar g) {
   return nb_strongly_connected_components(
       g, VF.bounded("nbSCC", 0, g.getNbMaxNodes(), g.getSolver()));
 }