source/cplex/model.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mobility Meeting Scheduler"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Constants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [],
   "source": [
    "SOLVER_TIME_LIMIT = 600\n",
    "\n",
    "MAXIMUM_FLIGHT_COST = 2500\n",
    "MAXIMUM_USEFUL_TIME = 2628288"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Students"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Imported 3 students, 7 destinations and the minimum time.\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "from datetime import datetime, timedelta\n",
    "\n",
    "# Import students information\n",
    "file = open('../../data/new/students.json')\n",
    "\n",
    "input = json.load(file)\n",
    "\n",
    "DESTINATIONS = input['destinations']\n",
    "MINIMUM_USEFUL_TIME = input['minimumTime']\n",
    "STUDENTS_INFO = input['students']\n",
    "N_STUDENTS = len(STUDENTS_INFO)\n",
    "\n",
    "STUDENTS_ORIGINS = [DESTINATIONS.index(x) for x in [student[\"city\"] for student in STUDENTS_INFO]]\n",
    "STUDENTS_STOPS = [student[\"maxConnections\"] for student in STUDENTS_INFO]\n",
    "STUDENTS_DURATIONS = [student[\"maxDuration\"] for student in STUDENTS_INFO]\n",
    "STUDENTS_DEPARTURES = [int(round(datetime.strptime(student[\"earliestDeparture\"], '%H:%M:%S').timestamp())) for student in STUDENTS_INFO]\n",
    "STUDENTS_ARRIVALS = [int(round(datetime.strptime(student[\"latestArrival\"], '%H:%M:%S').timestamp())) for student in STUDENTS_INFO]\n",
    "\n",
    "STUDENS_AVAILABILITIES = []\n",
    "for student in STUDENTS_INFO:\n",
    "    studentIntervals = []\n",
    "    for start, end in student[\"availability\"]:\n",
    "        studentIntervals.append(int(round(datetime.strptime(start + \" \" + student[\"earliestDeparture\"], '%d/%m/%Y %H:%M:%S').timestamp())))\n",
    "        studentIntervals.append(int(round(datetime.strptime(end + \" \" + student[\"latestArrival\"], '%d/%m/%Y %H:%M:%S').timestamp())))\n",
    "    STUDENS_AVAILABILITIES.append(studentIntervals)\n",
    "\n",
    "N_MAX_INTERVALS = max([int(len(x) / 2) for x in STUDENS_AVAILABILITIES])\n",
    "\n",
    "print(\"Imported\", N_STUDENTS, \"students,\", len(DESTINATIONS), \"destinations and the minimum time.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Flights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Imported 9323 flights!\n"
     ]
    }
   ],
   "source": [
    "# Import flights\n",
    "file = open('../../data/new/flights.json')\n",
    "\n",
    "FLIGHTS = json.load(file)\n",
    "\n",
    "# Add dummy flights\n",
    "def add_dummy_flight(city, date, time):\n",
    "    FLIGHTS.append({\n",
    "        \"origin\": city,\n",
    "        \"destination\": city,\n",
    "        \"departure\": date + \", \" + time,\n",
    "        \"arrival\": date + \", \" + time,\n",
    "        \"duration\": 0,\n",
    "        \"price\": \"0\",\n",
    "        \"stops\": 0\n",
    "    })\n",
    "\n",
    "for student in STUDENTS_INFO:\n",
    "    for start, end in student[\"availability\"]:\n",
    "        add_dummy_flight(student[\"city\"], start, student[\"earliestDeparture\"])\n",
    "        add_dummy_flight(student[\"city\"], end, student[\"latestArrival\"])\n",
    "\n",
    "\n",
    "FLIGHTS_ORIGINS = [DESTINATIONS.index(x) for x in [flight[\"origin\"] for flight in FLIGHTS]]\n",
    "FLIGHTS_DESTINATIONS = [DESTINATIONS.index(x) for x in [flight[\"destination\"] for flight in FLIGHTS]]\n",
    "\n",
    "FLIGHTS_DEPARTURES = [int(round(datetime.strptime(flight[\"departure\"], '%d/%m/%Y, %H:%M:%S').timestamp())) for flight in FLIGHTS]\n",
    "FLIGHTS_DEPARTURE_TIMES = [int(round(datetime.strptime(datetime.fromtimestamp(departure).time().isoformat(), '%H:%M:%S').timestamp())) for departure in FLIGHTS_DEPARTURES]\n",
    "\n",
    "FLIGHTS_ARRIVALS = [int(round(datetime.strptime(flight[\"arrival\"], '%d/%m/%Y, %H:%M:%S').timestamp())) for flight in FLIGHTS]\n",
    "FLIGHTS_ARRIVAL_TIMES = [int(round(datetime.strptime(datetime.fromtimestamp(arrival).time().isoformat(), '%H:%M:%S').timestamp())) for arrival in FLIGHTS_ARRIVALS]\n",
    "\n",
    "FLIGHTS_DURATIONS = [flight[\"duration\"] for flight in FLIGHTS]\n",
    "FLIGHTS_COSTS = [int(flight[\"price\"]) for flight in FLIGHTS]\n",
    "FLIGHTS_STOPS = [flight[\"stops\"] for flight in FLIGHTS]\n",
    "\n",
    "print(\"Imported\", len(FLIGHTS), \"flights!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {},
   "outputs": [],
   "source": [
    "from docplex.cp.model import CpoModel\n",
    "from docplex.cp.expression import INT_MIN, INT_MAX\n",
    "\n",
    "model = CpoModel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Chosen Destination\n",
    "Destination = model.integer_var(0, len(DESTINATIONS) - 1, \"Destination\")\n",
    "\n",
    "# Indexes of the flights each student has to take\n",
    "StudentsFlights = [model.integer_var_list(2, 0, len(FLIGHTS) - 1) for i in range(N_STUDENTS)]\n",
    "\n",
    "# Student avaliability interval\n",
    "StudentsAvailabilityIntervals = model.integer_var_list(N_STUDENTS, 0, N_MAX_INTERVALS, \"Interval\")\n",
    "\n",
    "# Cost for each of the students\n",
    "StudentsCosts = model.integer_var_list(N_STUDENTS, 0, MAXIMUM_FLIGHT_COST, \"StudentCost\")\n",
    "\n",
    "# Total trip cost\n",
    "TotalCost = model.integer_var(0, MAXIMUM_FLIGHT_COST * N_STUDENTS, \"TotalCost\")\n",
    "\n",
    "# Useful time\n",
    "UsefulTime = model.integer_var(0, MAXIMUM_USEFUL_TIME, \"UsefulTime\")\n",
    "\n",
    "# Separated Time\n",
    "SeparatedTime = model.integer_var(0, MAXIMUM_USEFUL_TIME, \"SeparatedTime\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Constraints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(N_STUDENTS):\n",
    "    Outgoing, Incoming = StudentsFlights[i]\n",
    "    StudentOrigin = model.element(STUDENTS_ORIGINS, i)\n",
    "\n",
    "    # Origin of the flights\n",
    "    model.add(model.element(FLIGHTS_ORIGINS, Outgoing) == StudentOrigin)\n",
    "    model.add(model.element(FLIGHTS_ORIGINS, Incoming) == Destination)\n",
    "\n",
    "    # Destination of the flights\n",
    "    model.add(model.element(FLIGHTS_DESTINATIONS, Outgoing) == Destination)\n",
    "    model.add(model.element(FLIGHTS_DESTINATIONS, Incoming) == StudentOrigin)\n",
    "\n",
    "    # Availability\n",
    "    startAvailability = model.element(STUDENS_AVAILABILITIES[i], StudentsAvailabilityIntervals[i] * 2)\n",
    "    endAvailability = model.element(STUDENS_AVAILABILITIES[i], StudentsAvailabilityIntervals[i] * 2 + 1)\n",
    "    model.add(model.element(FLIGHTS_DEPARTURES, Outgoing) >= startAvailability)\n",
    "    model.add(model.element(FLIGHTS_ARRIVALS, Incoming) <= endAvailability)\n",
    "\n",
    "    # Outgoing arrival time must be before Incoming departure time\n",
    "    model.add(model.element(FLIGHTS_ARRIVALS, Outgoing) < model.element(FLIGHTS_DEPARTURES, Incoming))\n",
    "\n",
    "    # Earliest departure\n",
    "    model.add(model.element(FLIGHTS_DEPARTURE_TIMES, Outgoing) >= model.element(STUDENTS_DEPARTURES, i))\n",
    "    model.add(model.element(FLIGHTS_DEPARTURE_TIMES, Incoming) >= model.element(STUDENTS_DEPARTURES, i))\n",
    "\n",
    "    # Latest arrival\n",
    "    model.add(model.element(FLIGHTS_ARRIVAL_TIMES, Outgoing) <= model.element(STUDENTS_ARRIVALS, i))\n",
    "    model.add(model.element(FLIGHTS_ARRIVAL_TIMES, Incoming) <= model.element(STUDENTS_ARRIVALS, i))\n",
    "\n",
    "    # Maximum number of stops\n",
    "    model.add(model.element(FLIGHTS_STOPS, Outgoing) <= model.element(STUDENTS_STOPS, i))\n",
    "    model.add(model.element(FLIGHTS_STOPS, Incoming) <= model.element(STUDENTS_STOPS, i))\n",
    "\n",
    "    # Maximum flight duration\n",
    "    model.add(model.element(FLIGHTS_DURATIONS, Outgoing) <= model.element(STUDENTS_DURATIONS, i))\n",
    "    model.add(model.element(FLIGHTS_DURATIONS, Incoming) <= model.element(STUDENTS_DURATIONS, i))\n",
    "\n",
    "    # Student Cost\n",
    "    studentCost = model.element(FLIGHTS_COSTS, StudentsFlights[i][0]) + model.element(FLIGHTS_COSTS, StudentsFlights[i][1])\n",
    "    model.add(studentCost == StudentsCosts[i])\n",
    "\n",
    "\n",
    "firstOutgoingTime = model.min([model.conditional(model.element(STUDENTS_ORIGINS, i) != Destination, model.element(FLIGHTS_ARRIVALS, StudentsFlights[i][0]), INT_MAX) for i in range(N_STUDENTS)])\n",
    "lastOutgoingTime = model.max([model.conditional(model.element(STUDENTS_ORIGINS, i) != Destination, model.element(FLIGHTS_ARRIVALS, StudentsFlights[i][0]), INT_MIN) for i in range(N_STUDENTS)])\n",
    "firstIncomingTime = model.min([model.conditional(model.element(STUDENTS_ORIGINS, i) != Destination, model.element(FLIGHTS_DEPARTURES, StudentsFlights[i][1]), INT_MAX) for i in range(N_STUDENTS)])\n",
    "lastIncomingTime = model.max([model.conditional(model.element(STUDENTS_ORIGINS, i) != Destination, model.element(FLIGHTS_DEPARTURES, StudentsFlights[i][1]), INT_MIN) for i in range(N_STUDENTS)])\n",
    "\n",
    "# Useful Time\n",
    "model.add(UsefulTime == firstIncomingTime - lastOutgoingTime)\n",
    "model.add(UsefulTime >= MINIMUM_USEFUL_TIME)\n",
    "\n",
    "# Separated Time\n",
    "model.add(SeparatedTime == (lastOutgoingTime - firstOutgoingTime) + (lastIncomingTime - firstIncomingTime))\n",
    "\n",
    "# Total cost\n",
    "model.add(TotalCost == model.sum(StudentsCosts))\n",
    "\n",
    "# Minimize function\n",
    "model.add(model.minimize(TotalCost / UsefulTime))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Search Phases\n",
    "Vars = [Destination] + [flight for student in StudentsFlights for flight in student]\n",
    "Varchooser = model.select_smallest(model.domain_max())\n",
    "Valuechooser = model.select_smallest(model.value())\n",
    "\n",
    "model.set_search_phases(model.search_phase(Vars, Varchooser, Valuechooser))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Solve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ! --------------------------------------------------- CP Optimizer 22.1.0.0 --\n",
      " ! Minimization problem - 16 variables, 52 constraints, 1 phase\n",
      " ! TimeLimit            = 600\n",
      " ! SearchType           = DepthFirst\n",
      " ! Initial process time : 0.63s (0.63s extraction + 0.00s propagation)\n",
      " !  . Log search space  : 151.8 (before), 151.8 (after)\n",
      " !  . Memory usage      : 10.3 MB (before), 10.3 MB (after)\n",
      " ! Using parallel search with 8 workers.\n",
      " ! ----------------------------------------------------------------------------\n",
      " !          Best Branches  Non-fixed    W       Branch decision\n",
      "                        0         16                 -\n",
      " + New bound is 0\n",
      " *     0.5108333        5  1.25s        1      (gap is 100.0%)\n",
      " *     0.4620833       10  1.25s        1      (gap is 100.0%)\n",
      " *    0.05598173       13  1.25s        1      (gap is 100.0%)\n",
      " *    0.05009132       17  1.25s        1      (gap is 100.0%)\n",
      " *    0.04995433       21  1.25s        1      (gap is 100.0%)\n",
      " *    0.04616438       29  1.25s        1      (gap is 100.0%)\n",
      " *    0.01287878       34  1.25s        1      (gap is 100.0%)\n",
      " *    0.01117870       37  1.25s        1      (gap is 100.0%)\n",
      " *    0.01114068       41  1.25s        1      (gap is 100.0%)\n",
      " *    0.01078662       48  1.25s        1      (gap is 100.0%)\n",
      " *    0.01075712       52  1.25s        1      (gap is 100.0%)\n",
      " *    0.01056840       61  1.25s        1      (gap is 100.0%)\n",
      " *   0.006988555       68  1.25s        1      (gap is 100.0%)\n",
      " *   0.006867545       71  1.25s        1      (gap is 100.0%)\n",
      " *   0.006409736       82  1.25s        1      (gap is 100.0%)\n",
      " *   0.006362007       85  1.25s        1      (gap is 100.0%)\n",
      " *   0.005930365       94  1.25s        1      (gap is 100.0%)\n",
      " *   0.004593280      100  1.25s        1      (gap is 100.0%)\n",
      " *   0.004291615      106  1.25s        1      (gap is 100.0%)\n",
      " ! Time = 1.25s, Average fail depth = 5, Memory usage = 44.3 MB\n",
      " ! Current bound is 0 (gap is 100.0%)\n",
      " !          Best Branches  Non-fixed    W       Branch decision\n",
      " *   0.004203074      111  1.25s        1      (gap is 100.0%)\n",
      " *   0.003834951      122  1.25s        1      (gap is 100.0%)\n",
      " *   0.003667781      142  1.25s        1      (gap is 100.0%)\n",
      " *   0.003416506      156  1.25s        1      (gap is 100.0%)\n",
      " *   0.003125399      166  1.25s        1      (gap is 100.0%)\n",
      " *   0.003097701      179  1.25s        1      (gap is 100.0%)\n",
      " *   0.002776371      184  1.25s        1      (gap is 100.0%)\n",
      " *   0.002448621      198  1.25s        1      (gap is 100.0%)\n",
      " *   0.002179581      216  1.25s        1      (gap is 100.0%)\n",
      " *   0.001831813      228  1.25s        1      (gap is 100.0%)\n",
      " *   0.001723064      234  1.25s        1      (gap is 100.0%)\n",
      " *   0.001700887      244  1.25s        1      (gap is 100.0%)\n",
      " *   0.001572736      255  1.25s        1      (gap is 100.0%)\n",
      " *   0.001530398      263  1.25s        1      (gap is 100.0%)\n",
      " *   0.001488589      274  1.25s        1      (gap is 100.0%)\n",
      " *   0.001309970      294  1.25s        1      (gap is 100.0%)\n",
      " *   0.001282979      307  1.25s        1      (gap is 100.0%)\n",
      " *   0.001218474      318  1.25s        1      (gap is 100.0%)\n",
      " *   0.001207467      323  1.25s        1      (gap is 100.0%)\n",
      " *   0.001120144      328  1.25s        1      (gap is 100.0%)\n",
      " ! Time = 1.25s, Average fail depth = 5, Memory usage = 44.2 MB\n",
      " ! Current bound is 0 (gap is 100.0%)\n",
      " !          Best Branches  Non-fixed    W       Branch decision\n",
      " *   0.001062590      342  1.25s        1      (gap is 100.0%)\n",
      " *   0.001017525      354  1.25s        1      (gap is 100.0%)\n",
      " *   0.001006723      360  1.25s        1      (gap is 100.0%)\n",
      " *  0.0009041047      386  1.25s        1      (gap is 100.0%)\n",
      " *  0.0008944999      389  1.25s        1      (gap is 100.0%)\n",
      " *  0.0008881199      417  1.25s        1      (gap is 100.0%)\n",
      " *  0.0008730779      422  1.25s        1      (gap is 100.0%)\n",
      " *  0.0008638339      425  1.25s        1      (gap is 100.0%)\n",
      " *  0.0008548431      429  1.25s        1      (gap is 100.0%)\n",
      " *  0.0007897793      438  1.25s        1      (gap is 100.0%)\n",
      " *  0.0007743547      441  1.25s        1      (gap is 100.0%)\n",
      " *  0.0007416911      467  1.25s        1      (gap is 100.0%)\n",
      " *  0.0007237272      470  1.25s        1      (gap is 100.0%)\n",
      " *  0.0007089743      476  1.25s        1      (gap is 100.0%)\n",
      " *  0.0006952590      510  1.25s        1      (gap is 100.0%)\n",
      " *  0.0006739955      514  1.25s        1      (gap is 100.0%)\n",
      " *  0.0006602564      519  1.25s        1      (gap is 100.0%)\n",
      " *  0.0006441525      523  1.25s        1      (gap is 100.0%)\n",
      " *  0.0005601227      528  1.25s        1      (gap is 100.0%)\n",
      " *  0.0005326340      532  1.25s        1      (gap is 100.0%)\n",
      " ! Time = 1.25s, Average fail depth = 5, Memory usage = 44.1 MB\n",
      " ! Current bound is 0 (gap is 100.0%)\n",
      " !          Best Branches  Non-fixed    W       Branch decision\n",
      " *  0.0005293705      559  1.25s        1      (gap is 100.0%)\n",
      " *  0.0005026455      563  1.25s        1      (gap is 100.0%)\n",
      " *  0.0004879173      575  1.25s        1      (gap is 100.0%)\n",
      " *  0.0004612098      579  1.25s        1      (gap is 100.0%)\n",
      " *  0.0004214334      614  1.25s        1      (gap is 100.0%)\n",
      " *  0.0004086021      631  1.25s        1      (gap is 100.0%)\n",
      " *  0.0004082312      635  1.25s        1      (gap is 100.0%)\n",
      " *  0.0004073981      639  1.25s        1      (gap is 100.0%)\n",
      " *  0.0003920993      646  1.25s        1      (gap is 100.0%)\n",
      " *  0.0003817204      656  1.25s        1      (gap is 100.0%)\n",
      " *  0.0002977346      683  1.25s        1      (gap is 100.0%)\n",
      " *  0.0002925989      690  1.25s        1      (gap is 100.0%)\n",
      " *  0.0002782558      693  1.25s        1      (gap is 100.0%)\n",
      " *  0.0002409638      697  1.25s        1      (gap is 100.0%)\n",
      " *  0.0002160493      710  1.25s        1      (gap is 100.0%)\n",
      " *  0.0001993127      718  1.25s        1      (gap is 100.0%)\n",
      " *  0.0001614255      735  1.25s        1      (gap is 100.0%)\n",
      " *  0.0001573849      738  1.25s        1      (gap is 100.0%)\n",
      " *  0.0001291364      741  1.25s        1      (gap is 100.0%)\n",
      " *  0.0001228171      747  1.25s        1      (gap is 100.0%)\n",
      " ! Time = 1.25s, Average fail depth = 5, Memory usage = 44.1 MB\n",
      " ! Current bound is 0 (gap is 100.0%)\n",
      " !          Best Branches  Non-fixed    W       Branch decision\n",
      " *  0.0001153776      758  1.25s        1      (gap is 100.0%)\n",
      " * 0.00009859450      785  1.25s        1      (gap is 100.0%)\n",
      " * 0.00009439899      789  1.25s        1      (gap is 100.0%)\n",
      " * 0.00008810572      793  1.25s        1      (gap is 100.0%)\n",
      " * 0.00007334720      805  1.25s        1      (gap is 100.0%)\n",
      " * 0.00006712696      809  1.25s        1      (gap is 100.0%)\n",
      " * 0.00006137322      813  1.25s        1      (gap is 100.0%)\n",
      " * 0.00005816066      822  1.25s        1      (gap is 100.0%)\n",
      " * 0.00005736309      825  1.25s        1      (gap is 100.0%)\n",
      " * 0.00005684341      829  1.25s        1      (gap is 100.0%)\n",
      " ! ----------------------------------------------------------------------------\n",
      " ! Search completed, 89 solutions found.\n",
      " ! Best objective         : 0.00005684341 (optimal - effective tol. is 5.684341e-09)\n",
      " ! Best bound             : 0\n",
      " ! ----------------------------------------------------------------------------\n",
      " ! Number of branches     : 6656\n",
      " ! Number of fails        : 2624\n",
      " ! Total memory usage     : 177.3 MB (177.3 MB CP Optimizer + 0.0 MB Concert)\n",
      " ! Time spent in solve    : 1.26s (0.63s engine + 0.63s extraction)\n",
      " ! Search speed (br. / s) : 10565.1\n",
      " ! ----------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "solution = model.solve(TimeLimit = SOLVER_TIME_LIMIT, SearchType = 'DepthFirst')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solution status: Optimal\n",
      "--> Destination: milano\n",
      "--> Total Cost: 64€\n",
      "--> Useful Time: 1125900 ( 13 days, 0:45:00 )\n",
      "--> Separated Time: 116400 ( 1 day, 8:20:00 )\n",
      "--> Students:\n",
      "    --> Student 1 departing from budapest:\n",
      "        OUTGOING FLIGHT:\n",
      "          01/06/2022, 08:15:00 -> 01/06/2022, 09:50:00 ( 1:35:00 )\n",
      "          Flight costs 13€ with 0 stops.\n",
      "        INCOMING FLIGHT:\n",
      "          14/06/2022, 21:00:00 -> 14/06/2022, 22:30:00 ( 1:30:00 )\n",
      "          Flight costs 5€ with 0 stops.\n",
      "    --> Student 2 departing from zagreb:\n",
      "        OUTGOING FLIGHT:\n",
      "          01/06/2022, 19:00:00 -> 01/06/2022, 20:15:00 ( 1:15:00 )\n",
      "          Flight costs 10€ with 0 stops.\n",
      "        INCOMING FLIGHT:\n",
      "          15/06/2022, 17:20:00 -> 15/06/2022, 18:35:00 ( 1:15:00 )\n",
      "          Flight costs 10€ with 0 stops.\n",
      "    --> Student 3 departing from wien:\n",
      "        OUTGOING FLIGHT:\n",
      "          01/06/2022, 06:50:00 -> 01/06/2022, 08:15:00 ( 1:25:00 )\n",
      "          Flight costs 16€ with 0 stops.\n",
      "        INCOMING FLIGHT:\n",
      "          15/06/2022, 09:05:00 -> 15/06/2022, 10:30:00 ( 1:25:00 )\n",
      "          Flight costs 10€ with 0 stops.\n"
     ]
    }
   ],
   "source": [
    "def print_flight(flight):\n",
    "    print(\"         \", flight[\"departure\"], \"->\", flight[\"arrival\"], \"(\", timedelta(minutes = flight[\"duration\"]), \")\")\n",
    "    print(\"          Flight costs \" + flight[\"price\"] + \"€ with \" + str(flight[\"stops\"]) + \" stops.\")\n",
    "\n",
    "if solution:\n",
    "    print(\"Solution status: \" + solution.get_solve_status())\n",
    "    print(\"--> Destination: \" + DESTINATIONS[solution[Destination]])\n",
    "    print(\"--> Total Cost: \" + str(solution[TotalCost]) + \"€\")\n",
    "    print(\"--> Useful Time:\", solution[UsefulTime], \"(\", timedelta(seconds = solution[UsefulTime]), \")\")\n",
    "    print(\"--> Separated Time:\", solution[SeparatedTime], \"(\", timedelta(seconds = solution[SeparatedTime]), \")\")\n",
    "    print(\"--> Students:\")\n",
    "\n",
    "    for i in range(N_STUDENTS):\n",
    "        Outgoing, Incoming = StudentsFlights[i]\n",
    "\n",
    "        print(\"    --> Student \" + str(i + 1) + \" departing from \" + STUDENTS_INFO[i][\"city\"] + \":\")\n",
    "\n",
    "        if STUDENTS_ORIGINS[i] == solution[Destination]:\n",
    "            print(\"       - Student need not to take any flights!\")\n",
    "        else:\n",
    "            print(\"        OUTGOING FLIGHT:\")\n",
    "            print_flight(FLIGHTS[solution[Outgoing]])\n",
    "            print(\"        INCOMING FLIGHT:\")\n",
    "            print_flight(FLIGHTS[solution[Incoming]])\n",
    "\n",
    "else:\n",
    "    print(\"No solution found\")"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "0c7a622481a4ee3c77e2194436dca1746ca024df51366a091b5d2574d23653a1"
  },
  "kernelspec": {
   "display_name": "Python 3.8.12 ('base')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}