using System;

using Google.OrTools.LinearSolver;

​

public class SimpleMipProgram

{

    static void Main()

    {

        int numLoadingPlaces = 5;

        int numTimePeriod = 4;

        int numBookings = 3;

        int numMaxConstraints = 1; 

        int valMaxConstraint = 4;

        // Create the linear solver with the SCIP backend.

        Solver solver = Solver.CreateSolver("SCIP");

        if (solver is null)

        {

            return;

        }

​

        Objective objective = solver.Objective();

​

        // Or we create a matrix (numBookings x numLoadingPlaces);

        // For each booking we create a bolean variale array

        Variable[,] booking = new Variable[numBookings, numLoadingPlaces];

        Variable[] bookingError = new Variable[numBookings];

​

        // Each booking need to be place at 1 loading place

        for (int k=0; k < numBookings; k++)

        {

            bookingError[k] = solver.MakeBoolVar("bookingErrork");

            Constraint bookingConstraint = solver.MakeConstraint();

            bookingConstraint.SetBounds(1.0,1.0) ; // sum booking var = 1

            for (int j=0; j < numLoadingPlaces; j++)

            {

                if (j >= 3) // here we suppose that only loading place 4 and 5 are possible

                {

                    // constraint on booking can only be place at possible loading place

                    booking[k,j] = solver.MakeBoolVar("booking[k,j]"); // PossibleLoadingPlace

                }

                else

                {

                    // constraint  on booking can only be place at possible loading place

                    booking[k,j] = solver.MakeIntVar(0,0,"booking[k,j]");  // Not a possible loading place

                }

                bookingConstraint.SetCoefficient(booking[k,j],1);

            }

        }

​

​

​

        // capacity is a boolean variable 

        Variable[,] capacity = new Variable[numLoadingPlaces, numTimePeriod];

        // Impossible capacity is a boolean variable 

        //Variable[,] capacityError = new Variable[numLoadingPlaces,numTimePeriod];

​

        // we repeat on the time period

        for (int i=0; i < numTimePeriod; i++) {

            // each max restriction that applied in the time period will add a constraint (ex max 2)

            Constraint[] maxRestrictionsConstraint = new Constraint[numMaxConstraints] ;

            Variable[] maxRestrictionsConstraintError = solver.MakeIntVarArray(numMaxConstraints,0,numBookings);

            maxRestrictionsConstraint[0] = solver.MakeConstraint();

            maxRestrictionsConstraint[0].SetUb(valMaxConstraint) ;

​

            // each capacity booking have either capacity or booking (or nothing)

            for (int j=0; j < numLoadingPlaces; j++)

            {

                // define capacity variable

                capacity[j,i] = solver.MakeBoolVar("capacity_j,i");

​

                // define capacity error varible

                //capacityError[j,i] = solver.MakeIntVar(0,numBookings,"capacityError_i");

​

                // objective is to maximize capacity

                objective.SetCoefficient(capacity[j,i], 1);

                // With an weighting negative error component

                //objective.SetCoefficient(capacityError[j,i], -10);

​

                // for each loading place we put a constraint on the capacity - capacityError + bookings <= 1

                Constraint loadingPlaceConstraint = solver.MakeConstraint();

                loadingPlaceConstraint.SetUb(1); // sum <= 1

                loadingPlaceConstraint.SetCoefficient(capacity[j,i],1);

                //loadingPlaceConstraint.SetCoefficient(capacityError[j,i],-1);

                // for each max constraint w put a constraint on the capacity - restrictionError + bookings <= maxRestriction

                // if the loadingPlace is applicable for the maxRestriction

                maxRestrictionsConstraint[0].SetCoefficient(capacity[j,i],1);

                // With an weighting negative error component

                objective.SetCoefficient(maxRestrictionsConstraintError[0], -10);

                maxRestrictionsConstraint[0].SetCoefficient(maxRestrictionsConstraintError[0],-1);

                // loop over the booking that are applicable in the time period

                for (int k=0; k < numBookings; k++) 

                {

                    // applicable booking in time period

                    loadingPlaceConstraint.SetCoefficient(booking[k,j],1);

                    loadingPlaceConstraint.SetCoefficient(bookingError[k],-1);

                    // applicable booking in time period + applicationRetriction in time period + applicable loading place in restriction x

                    maxRestrictionsConstraint[0].SetCoefficient(booking[k,j],1);

                }

            }

        }

​

        // Add a negative weighting on booking erro

        for (int k=0; k < numBookings; k++) 

        {

            // With an weighting negative error component

            objective.SetCoefficient(bookingError[k], -10);

​

        }       

        // Maximize capacity.

        objective.SetMaximization();

        // Launch the result calculation

        Solver.ResultStatus resultStatus = solver.Solve();

        // print result

        Console.WriteLine("Solution:");

        Console.WriteLine("Objective value = " + solver.Objective().Value());

​

        for (int j=0; j < numLoadingPlaces; j++) 

        {

            Console.Write("capacity["+j+"]=[ ");

​

            for (int i=0; i < numTimePeriod; i++) 

            {

                Console.Write(capacity[j,i].SolutionValue() + " ");

            }

            Console.Write("]\n");

​

        }

        Console.WriteLine("");

        for (int k=0; k < numBookings; k++) 

        {

            Console.Write("booking=["+ k + "] = [");    

            for (int j=0; j < numLoadingPlaces; j++) 

            {

                Console.Write(booking[k,j].SolutionValue() + " ");

            }

            Console.Write("]\n");

            Console.WriteLine("bookingError=["+ k + "] = " + bookingError[k].SolutionValue() + " ");    

        }   

        Console.WriteLine("");

    }

}