//
// Given a n skippers and m boats, produce a round robin schedule
// with at most m/2 matches per round, respecting the constraint that the
// players in the last match of a round cannot participate in the first 
// match of the next round, and if 5 or more matches in a round, the
// first match in the next round does not contain either skipper from the
// second last match in this round 
//
import static choco.Choco.*;
import choco.cp.model.CPModel;
import choco.kernel.model.Model;
import choco.kernel.model.variables.integer.IntegerVariable;
import choco.cp.solver.CPSolver;
import choco.kernel.solver.Solver;
import choco.kernel.solver.variables.integer.IntDomainVar;
import choco.cp.solver.search.integer.varselector.*;
import choco.cp.solver.search.integer.valselector.*;

public class Phase0 {

    Model model;
    Solver solver;
    int n;                        // contestants
    int m;                        // maximum number of matches in a round
    int matches;                  // number of matches overall
    IntegerVariable[] fMatch;     // flattened match, for all difference
    int rounds;                   // number of rounds
    int boats;                    // number of boats given
    IntegerVariable[][] match;    // match[i][j] = k <-> contestants i and j are in a match in round k/m position k%m

    Phase0 (int n,int boats) {
	this.n     = n;
	this.m     = boats/2;
	matches    = n*(n-1)/2;
	rounds     = (int)Math.ceil((double)matches/(double)m);
	model      = new CPModel();
	solver     = new CPSolver();
	match      = new IntegerVariable[n][n];
	fMatch     = new IntegerVariable[matches];
	this.boats = boats;

	for (int i=0,k=0;i<n-1;i++)
	    for (int j=i+1;j<n;j++,k++)
		fMatch[k] = match[i][j] = match[j][i] = makeIntVar("match["+ i +"]["+ j +"]",0,m*rounds-1);
	//
	// create constrained integer variables match and its flattened fMatch
	// NOTE: match[i][j] is exactly equivalent to match[j][i]
	//

	for (int i=0;i<n;i++) match[i][i] = constant(m*rounds+i);
	//
	// leading diagonal filled with wild/impossible/unique entries
	//

	for (int i=0;i<n;i++)
	    for (int j=0;j<n-1;j++) 
		for (int k=j+1;k<n;k++)
		    model.addConstraint(neq(div(match[i][j],m),div(match[i][k],m)));
	//
	// for a competitor i, all his matches must take place in different rounds
	// where a round is match[i][j]/m
	// NOTE: could supplement this with a n by n array where values are round
	//       a match takes place in. We then exploit allDiff and maybe more 
	//       get propagation
	//

	for (int i=0;i<n;i++)
	    for (int j=0;j<n-1;j++) 
		for (int k=j+1;k<n;k++)
		    model.addConstraint(distanceNEQ(match[i][j],match[i][k],1));
	//
	// If competitor i is in the last slot in a round 
	// Then that competitor is not allowed to be in first slot of next round
	//
	// NOTE: "Principal Criteria ... 4. No skipper in the last match of a flight 
	//        should be in the first match of the next flight"
	//

	if (m > 4)
	    for (int i=0;i<n;i++)
		for (int j=0;j<n-1;j++)
		    for (int k=j+1;k<n;k++){
			IntegerVariable x = match[i][j];
			IntegerVariable y = match[i][k];
			model.addConstraint(implies(and(eq(mod(x,m),m-2),eq(div(x,m),minus(div(y,m),1))),neq(mod(y,m),0)));
			// IF match x is second last in flight (x%m = m-2) and match y is in the next flight (x/m = y/m + 1)
			// THEN match y cannot be in 1st slot in next flight (y%m <> 0)
			model.addConstraint(implies(and(eq(mod(y,m),m-2),eq(div(y,m),minus(div(x,m),1))),neq(mod(x,m),0)));
			// as above but with x and y swapped
		    }
	//
	// If at least 5 matches in a flight 
	// Then skippers in second last match in a flight cannot
	//      be in first match of next flight
	//
	// NOTE: "Principal Criteria ... 7. In flights with five or more matches no skipper
	//        should be in the next-to-last match in a flight and then in the first
	//        match of the next flight."
	//

	model.addConstraint(allDifferent(fMatch));
	//
	// every match takes place in a different time slot
	//

	solver.read(model);
	//solver.setValIntSelector(new MidVal());
	solver.setValIntSelector(new RandomIntValSelector());
	//solver.setVarIntSelector(new RandomIntVarSelector(solver));
	//solver.setVarIntSelector(new MaxDomain(solver)); //,solver.getVar(fMatch)));
	solver.setVarIntSelector(new MinDomain(solver,solver.getVar(fMatch))); // search over decision variables
    }

    boolean solve(){return solver.solve();}

     void result(){
	 int[][][] schedule = new int[rounds][m][2];
	 for (int i=0;i<rounds;i++)
	     for (int j=0;j<m;j++) schedule[i][j][0] = -1;
	 for (int i=0;i<n-1;i++)
	     for (int j=i+1;j<n;j++){
		 int slot = solver.getVar(match[i][j]).getVal();
		 int round = slot/m;
		 int position = slot%m;
		 schedule[round][position][0] = i;
		 schedule[round][position][1] = j;
	     }
	 System.out.println(n +" skippers  "+ boats +" boats  "+ matches +" matches  "+ rounds +" flights  "+ m +" boatPairs");
	 for (int round=0;round<rounds;round++){
	     System.out.print("flight: "+ round);
	     for (int position=0;position<m;position++)
		 if (schedule[round][position][0] != -1) System.out.print(" ("+ schedule[round][position][0] +","+ schedule[round][position][1] +")");
	     System.out.println();
	 }
     }
    //
    // pretty output
    //
    
    void outPut(){
	System.out.println(n +" "+ rounds +" "+ boats);
	 for (int i=0;i<n;i++){
	     for (int j=0;j<n;j++)
		 System.out.print(solver.getVar(match[i][j]).getVal() +" ");
	     System.out.println();
	 }
    }
    //
    // for input to next phase
    //

    void stats(){
	System.out.println("nodes: "+ solver.getNodeCount() +"   cpu: "+ solver.getTimeCount());
    }
     
    public static void main(String args[]) {
	int n          = Integer.parseInt(args[0]);
	int m          = Integer.parseInt(args[1]);
	Phase0 rrSched = new Phase0(n,Math.min(n,m)); // round-robin schedule
	rrSched.solve();
	rrSched.outPut();
	rrSched.stats();
	rrSched.result();
    }
}