using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using Gurobi;

using OLRPTW;

​

namespace OLRPTW_Full

{

    public class Program

    {

        static void Main()

        {

            try

            {

                int C = 3;                     //Number of customers

                //static int P = 6;                     //Number of routes

                int M = 2;                     //Number of depot                

                int N = C + M;                 //Number of nodes

                int DC1 = C + 1;

                double Capacity = 60;

​

                //static double[] DualU = new double[C];

                //static double[] DualV = new double[M];

                double[] DualU = new double[] { 0, 440, 430, 430 };

                double[] DualV = new double[] { -10, -10 };

                double[] Q = new double[] { 200, 200 };  //DC capacity           

                double[] f = new double[] { 2000, 2000 }; //DC opening cost

                //static int Vcost = 200; //vehicle fixed cost                           

                double[] Demand = { 0, 20, 20, 20 }; //customer demand                       

                //double[,] Distance =         //distance

                //    {

                //        { 0,20,15,26},

                //        {20, 0,32,32},

                //        {15,32, 0,24},

                //        {26,32,24, 0}

                //    };

​

                double[, ,] Distance =         //distance

                {{

                { 0,20,15,26},

                {20, 0,32,32},

                {15,32, 0,24},

                {26,32,24, 0},

            },

            {

                { 0,50,26,15},

                {20, 0,32,32},

                {26,32, 0,24},

                {15,32,24, 0},

            }};

​

                //service time;

                double[] servicetime = { 0, 10, 10, 10 };

                double[, ,] time = new double[M, C + 1, C + 1];

                double[, ,] ReducedCost = new double[M, C + 1, C + 1];

​

                //time windows

                int[] A = { 0, 10, 100, 50 };

                int[] B = { 200, 30, 120, 70 };

​

                //static double[] c = { 240, 230, 252, 240, 252, 230 };  //cost of each route p

                //static double[] d = { 20, 20, 20, 20, 20, 20 };             //cumulative demand each route

                //static List<Matrix> a = new List<Matrix>();

                //static List<Matrix> v = new List<Matrix>();

                //static List<Label> AlreadyAdd = new List<Label>();

​

                //static int[,] a =

                //    new int[,] {

                //        {1,0,0,1,0,0},

                //        {0,1,0,0,1,0},

                //        {0,0,1,0,0,1}

                //        };

​

                //static int[,] v =

                //   new int[,] {

                //        {1,0},

                //        {1,0},

                //        {1,0},

                //        {0,1},

                //        {0,1},

                //        {0,1}

                //        };

​

                //calculate time

                for (int m = 0; m < M; ++m)

                {

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

                    {

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

                        {

                            if (i != j)

                            {

                                time[m, i, j] = Distance[m, i, j] + servicetime[i];

                            }

                            else if (i == j)

                            { time[m, i, j] = 0; }

                            //Console.WriteLine(time[m, i, j]);

                        }

                    }

                }

​

                //calculate reduced cost

                for (int m = 0; m < M; ++m)

                {

                    for (int i = 0; i < C+1; ++i)

                    {

                        for (int j = 0; j < C + 1; ++j)

                        {

                            ReducedCost[m, i, j] = Distance[m, i, j] - DualU[i] + Demand[i] * DualV[m];

                            //Console.WriteLine(ReducedCost[m, i, j]);

                        }

                    }

                }

​

                var sub = new List<Subproblem>();

                Subproblem s = new Subproblem();

                s.x = new double[DC1, DC1];

                //List<double> RC = new List<double>();

                //List<List<int>> route = new List<List<int>>();

​

                //for depot m = 1...M

                for (int m = 0; m < M; ++m)

                {

                    // Model

                    GRBEnv env = new GRBEnv();

                    GRBModel model = new GRBModel(env);

​

                    model.ModelName = "OLRPTW Subproblem";

​

                    GRBVar[,] x = new GRBVar[C + 1, C + 1];     //variable of route

                    GRBVar[] D = new GRBVar[C + 1];     //variable of duration

                    GRBVar[] U = new GRBVar[C + 1];     //variable of cumulative demand

                    //GRBVar[,] U = new GRBVar[DC1,DC1];     //variable of cumulative demand

                    //GRBVar[,] time = new GRBVar[DC1, DC1];

                    //GRBVar[,] ReducedCost = new GRBVar[DC1, DC1];

​

                    for (int i = 0; i < C + 1; ++i)

                    {

                        for (int j = 0; j < C + 1; ++j)

                        {

                            x[i, j] = model.AddVar(0.0, 1.0, 0.0, GRB.BINARY, "x" + i + "," + j);

                        }

                    }

​

                    for (int i = 0; i < C + 1; ++i)

                    {

                        D[i] = model.AddVar(A[i], B[i], 0.0, GRB.CONTINUOUS, "D" + i);

                    }

​

                    for (int i = 0; i < C + 1; ++i)

                    {

                        U[i] = model.AddVar(Demand[i], Capacity, 0.0, GRB.CONTINUOUS, "U" + i);

                    }

​

​

                    // Integrate new variables

                    model.Update();

​

                        //objective function 

                        GRBLinExpr sumRC = 0.0;

                        for (int i = 0; i < C+1; ++i)

                        {

                            for (int j = 0; j < C+1; ++j)

                            {

                                if (i != j)

                                    sumRC += ReducedCost[m, i, j] * x[i, j];

                            }

                        }

​

                        model.SetObjective(sumRC, GRB.MINIMIZE);

​

​

                        //constraint 1

​

                        for (int i = 1; i < DC1; ++i)

                        {

                            GRBLinExpr sumJ = new GRBLinExpr();

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

                            {

                                if (i != j)

                                    sumJ.AddTerm(1.0, x[i, j]);

                            }

                            model.AddConstr(sumJ <= 1.0, "C1" + i);

                        }

​

                        //constraint 2

                        for (int j = 1; j < DC1; ++j)

                        {

                            GRBLinExpr sumI = new GRBLinExpr();

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

                            {

                                if (i != j)

                                    sumI.AddTerm(1.0, x[i, j]);

                            }

                            model.AddConstr(sumI == 1.0, "C2" + j);

                        }

​

                        //constraintxx

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

                        {

                            GRBLinExpr sumXij = new GRBLinExpr();

                            for (int i = 1; i < DC1; ++i)

                            {

                                sumXij.AddTerm(1.0, x[i, j]);

                            }

                            model.AddConstr(sumXij == 0.0, "Cxx" + j);

                        }

​

                        //constraint 3

​

                        for (int i = 1; i < DC1; ++i)

                        {

                            for (int j = 1; j < DC1; ++j)

                            {

                                if (i != j)

                                    model.AddConstr(U[j] - U[i] + Capacity * x[i, j] <= Capacity - Demand[i], "Cap" + i + j);

                            }

                        }

​

                        //constraint 5                    

                        for (int i = 1; i < DC1; ++i)

                        {

                            for (int j = 1; j < DC1; ++j)

                            {

                                if (i != j)

                                    model.AddConstr(D[i] + time[m, i, j] - D[j] <= 10000 * (1 - x[i, j]), "Time" + i + j);

                            }

                        }

​

                        //write .lp file for debugging;

                        //model.Write("LRPTW_cs.lp");

​

                        // Solve

                        model.Optimize();

​

​

                        int status = model.Get(GRB.IntAttr.Status);

​

                        if (status == GRB.Status.INF_OR_UNBD ||

                          status == GRB.Status.INFEASIBLE ||

                          status == GRB.Status.UNBOUNDED)

                        {

                            Console.WriteLine("The model cannot be solved " +

                                     "because it is infeasible or unbounded");

                        }

​

                        if (model.Status == GRB.Status.OPTIMAL)

                        {                                                        

                            //RC.Add(model.ObjVal);

                            s.ReducedCost = model.ObjVal;

                            //List<int> routeContent = new List<int>();

​

                            Console.WriteLine("\nDepot " + m + ": ");

                            Console.WriteLine("\nTotal cost: " + model.ObjVal);

                            Console.WriteLine("\nRoute:");

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

                            {

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

                                {

                                    s.x[i, j] = x[i, j].X;

                                    if (x[i, j].X == 1)

                                    {

                                        Console.WriteLine(x[i, j].VarName + " " + x[i, j].X);

                                        //routeContent.Add(j);

                                    }

                                }

                            }

​

                            sub.Add(s);

                            //route.Add(routeContent);

                            //Console.WriteLine("\nUsed Capacity:");

                            //for (int i = 0; i < DC1; ++i)

                            //{ Console.WriteLine(U[i].VarName + " " + U[i].X); }

                        }

                    }

                    double minRC = sub.Min(a => a.ReducedCost);

                    //int minRCIdx = sub.IndexOf(minRC);

                    int minRCIdx = sub.IndexOf(minRC);

                    Console.WriteLine("\nMinimum reduced cost: " + minRC);

​

                    //for (int id = 0; id < route[minRCIdx].Count; id++)

                    //{

                    //    Console.Write(route[minRCIdx][id] + " ");

                    //}

                    Console.WriteLine();

                }

            catch (GRBException e)

            {

                Console.WriteLine("Error code: " + e.ErrorCode + ". " +

                    e.Message);

            }

        }

    }

}