//
// Given a round robin schedule, that respects last/first in round constraint
// Allocate boats to minimise the maximum number of boat changes over all skippers
//
import java.util.*;
import java.io.*;
import static choco.Choco.*;
import choco.cp.model.CPModel;
import choco.cp.solver.CPSolver;
import choco.kernel.model.Model;
import choco.kernel.solver.Solver;
import choco.kernel.model.variables.integer.IntegerVariable;
import choco.cp.solver.search.integer.varselector.MinDomain;
import choco.kernel.solver.ContradictionException;

public class Phase1a {
    Model model;  
    Solver solver; 
    int n, rounds, boats;
    int[][] schedule;        // constant, schedule[i][j] = k <-> match(i,j) at timeslot k
    Round[] round;           // an array of rounds
    Skipper[] skipper;       // an array of skippers
    IntegerVariable changes; // the maximum boat changes for a skipper
    int matchesPerRound;     // the maximum number of matches in a round (boats/2)
    IntegerVariable[] boat;  // the decision variables

    Phase1a (String fname) throws IOException {
	Scanner sc      = new Scanner(new File(fname));
	n               = sc.nextInt();                 // number of skippers
	rounds          = sc.nextInt();                 // number of rounds
	boats           = sc.nextInt();                 // number of boats
	schedule        = new int[n][n];                // as read in
	round           = new Round[rounds];
	skipper         = new Skipper[n];
	model           = new CPModel();
	solver          = new CPSolver();
	changes         = makeIntVar("changes",0,n-1);  // maximum boat changes over all skippers
	matchesPerRound = boats/2;                      // of course
	boat            = new IntegerVariable[n*(n-1)]; // the decision variables

	for (int i=0;i<n;i++)
	    for (int j=0;j<n;j++)
		schedule[i][j]  = sc.nextInt(); // timeslot for match(i,j)
	sc.close();
	//
	// read in schedule
	//

	for (int i=0;i<rounds;i++) round[i] = new Round(i,boats);
	for (int i=0;i<n;i++) skipper[i] = new Skipper(i,n-1,boats);
	for (int i=0,k=0;i<n-1;i++)
	    for (int j=i+1;j<n;j++){
		Match m = new Match(i,j,schedule[i][j],boats);
		int r = schedule[i][j]/matchesPerRound;
		round[r].add(m);
		skipper[i].add(m);
		skipper[j].add(m);
		boat[k++] = m.boat1;
		boat[k++] = m.boat2;
	    }
	//
	// from the schedule produce the matches and add these
	// to the appropraite rounds and skippers
	//

	for (Round r : round) r.allDifferentBoats(model);
	//
	// constrain each round such that all boats used in matches in
	// that round are all different
	//

	for (int i=0;i<n;i++){
	    skipper[i].penalizeBoatChange(model);
	    model.addConstraint(geq(changes,skipper[i].numberOfChanges));
	}
	//
	// for each skipper
	//    order matches chronologically
	//    for the boats to be allocated to those matches for that skipper
	//    when there is a change of boats there is a penalty
	//

	/*
	for (int i=0;i<n-1;i++)
	    for (int j=i+1;j<n;j++)
		model.addConstraint(distanceLT(skipper[i].numberOfChanges,skipper[j].numberOfChanges,3));
	*/

	solver.read(model);	
	solver.setVarIntSelector(new MinDomain(solver,solver.getVar(boat))); // search over decision variables
    }
    //
    // NOTE: we might add constraints to limit the difference in number
    //       of boat changes between skippers. For example, we might limit
    //       the difference to be at most 2
    //

    void output(){
	MatchComparator MC = new MatchComparator();
	for (Round r : round){
	    Collections.sort(r.match,MC);
	    for (Match m : r.match)
		System.out.print("(s"+ m.player1 +"/b"+ solver.getVar(m.boat1).getVal() +",s"+
				 m.player2 +"/b"+ solver.getVar(m.boat2).getVal() +") ");
	    System.out.println();
	}
	for (Skipper s : skipper){
	    System.out.print("skipper_"+s.id +" changes "+ solver.getVar(s.numberOfChanges).getVal() +" -> ");
	    for (IntegerVariable b : s.boat) System.out.print(solver.getVar(b).getVal() +" ");
	    System.out.println();
	}	
    }                                  

    boolean minimize(){return solver.minimize(solver.getVar(changes),false);}

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

    void stats(){
	System.out.println("nodes: "+ solver.getNodeCount() +"   cpu: "+ solver.getTimeCount());
    }
    
    public static void main(String[] args)  throws IOException {
	Phase1a allocBoats = new Phase1a (args[0]);
	int timeout = 0;
	if (args.length > 1) allocBoats.solver.setTimeLimit(Integer.parseInt(args[1]) * 1000);
	System.out.println(allocBoats.minimize());
	//System.out.println(allocBoats.solve());
	allocBoats.stats();
	allocBoats.output();        
    }
}