{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import copy\n",
    "import re\n",
    "from dataclasses import dataclass\n",
    "from functools import lru_cache\n",
    "from typing import List, Tuple\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import numpy.random as rnd\n",
    "\n",
    "from alns import ALNS\n",
    "from alns.accept import HillClimbing\n",
    "from alns.select import SegmentedRouletteWheel\n",
    "from alns.stop import MaxIterations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "SEED = 5432"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# The resource-constrained project scheduling problem\n",
    "\n",
    "The following explanation is largely based on [this paper](https://pms2020.sciencesconf.org/300164/document).\n",
    "\n",
    "The goal of the RCPSP is to schedule a set of project activities $V = \\{ 0, 1, 2, \\ldots, n \\}$, such that the makespan of the project is minimised.\n",
    "Each activity $i \\in V$ has a duration $d_i \\in \\mathbb{N}$.\n",
    "Precedence constraints impose that an activity $i \\in V$ can only start after all its predecessor activities have been completed.\n",
    "The precedence constraints are given by a set of edges $E \\subset V \\times V$, where $(i, j) \\in E$ means that $i$ must be completed before $j$ can commence.\n",
    "Resource constraints, on the other hand, impose that an activity can only be scheduled if sufficient resources are available.\n",
    "There are $K = \\{ 1, 2, \\ldots, m \\}$ renewable resources available, with $R_k$ indicating the availability of resource $k$.\n",
    "Each activity $i \\in V$ requires $r_{ik}$ units of resource $k$.\n",
    "A solution to the RCPSP is a schedule of activities $S = \\{ S_0, S_1, \\ldots, S_n \\}$, where $S_i$ is the starting time of activity $i$.\n",
    "The project starts at time $S_0 = 0$, and completes at $S_n$, where activities $0$ and $n$ are dummy activities that represent the start and completion of the project, respectively.\n",
    "\n",
    "In this notebook, we solve an instance of the RCPSP using ALNS.\n",
    "In particular, we solve instance `j9041_6` of the [PSPLib](http://www.om-db.wi.tum.de/psplib/library.html) benchmark suite.\n",
    "This instance consists of 90 jobs, and four resources.\n",
    "The optimal makespan of this instance is known to be between 123 and 135.\n",
    "We find a solution with a makespan of 141, just 4% above the best known solution to this instance.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Data instance\n",
    "\n",
    "We use the [dataclass](https://docs.python.org/3/library/dataclasses.html#dataclasses.dataclass) decorator to simplify our class representation a little."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "@dataclass(frozen=True)\n",
    "class ProblemData:\n",
    "    num_jobs: int\n",
    "    num_resources: int\n",
    "\n",
    "    duration: np.ndarray  # job durations\n",
    "    successors: List[List[int]]  # job successors\n",
    "    predecessors: List[List[int]]  # job predecessors\n",
    "    needs: np.ndarray  # job resource needs\n",
    "    resources: np.ndarray  # resource capacities\n",
    "\n",
    "    def __hash__(self) -> int:\n",
    "        return id(self)\n",
    "\n",
    "    @property\n",
    "    def first_job(self) -> int:\n",
    "        return 0\n",
    "\n",
    "    @property\n",
    "    def last_job(self) -> int:\n",
    "        return self.num_jobs - 1\n",
    "\n",
    "    @property\n",
    "    @lru_cache(1)\n",
    "    def all_predecessors(self) -> List[List[int]]:\n",
    "        pred = [set() for _ in range(self.num_jobs)]\n",
    "\n",
    "        for job, pre in enumerate(self.predecessors):\n",
    "            for p in pre:\n",
    "                pred[job] |= pred[p] | {p}\n",
    "\n",
    "        return [sorted(p) for p in pred]\n",
    "\n",
    "    @property\n",
    "    @lru_cache(1)\n",
    "    def all_successors(self) -> List[List[int]]:\n",
    "        succ = [set() for _ in range(self.num_jobs)]\n",
    "\n",
    "        for job, suc in zip(reversed(range(self.num_jobs)),\n",
    "                            reversed(self.successors)):\n",
    "            for s in suc:\n",
    "                succ[job] |= succ[s] | {s}\n",
    "\n",
    "        return [sorted(s) for s in succ]\n",
    "\n",
    "    @classmethod\n",
    "    def read_instance(cls, path: str) -> \"ProblemData\":\n",
    "        \"\"\"\n",
    "        Reads an instance of the RCPSP from a file.\n",
    "        Assumes the data is in the PSPLib format.\n",
    "\n",
    "        Loosely based on:\n",
    "        https://github.com/baobabsoluciones/hackathonbaobab2020.\n",
    "        \"\"\"\n",
    "        with open(path) as fh:\n",
    "            lines = fh.readlines()\n",
    "\n",
    "        prec_idx = lines.index(\"PRECEDENCE RELATIONS:\\n\")\n",
    "        req_idx = lines.index(\"REQUESTS/DURATIONS:\\n\")\n",
    "        avail_idx = lines.index(\"RESOURCEAVAILABILITIES:\\n\")\n",
    "\n",
    "        successors = []\n",
    "\n",
    "        for line in lines[prec_idx + 2: req_idx - 1]:\n",
    "            _, _, modes, num_succ, *jobs, _ = re.split(\"\\s+\", line)\n",
    "            successors.append(list(map(lambda x: int(x) - 1, jobs)))\n",
    "\n",
    "        predecessors = [[] for _ in range(len(successors))]\n",
    "\n",
    "        for job in range(len(successors)):\n",
    "            for succ in successors[job]:\n",
    "                predecessors[succ].append(job)\n",
    "\n",
    "        needs = []\n",
    "        durations = []\n",
    "\n",
    "        for line in lines[req_idx + 3: avail_idx - 1]:\n",
    "            _, _, _, duration, *consumption, _ = re.split(\"\\s+\", line)\n",
    "\n",
    "            needs.append(list(map(int, consumption)))\n",
    "            durations.append(int(duration))\n",
    "\n",
    "        _, *avail, _ = re.split(\"\\s+\", lines[avail_idx + 2])\n",
    "        resources = list(map(int, avail))\n",
    "\n",
    "        return ProblemData(len(durations),\n",
    "                           len(resources),\n",
    "                           np.array(durations),\n",
    "                           successors,\n",
    "                           predecessors,\n",
    "                           np.array(needs),\n",
    "                           np.array(resources))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "instance = ProblemData.read_instance('data/j9041_6.sm')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "DELTA = 0.75  # resource utilisation threshold\n",
    "ITERS = 5_000\n",
    "\n",
    "START_TRESH = 5  # start threshold for RRT\n",
    "STEP = 20 / ITERS  # step size for RRT\n",
    "\n",
    "THETA = 0.9  # weight decay parameter\n",
    "WEIGHTS = [25, 5, 1, 0]  # weight scheme weights\n",
    "SEG_LENGTH = 100  # weight scheme segment length\n",
    "\n",
    "Q = int(0.2 * instance.num_jobs)\n",
    "\n",
    "LB = 123  # lower bound on optimal makespan\n",
    "UB = 135  # upper bound on optimal makespan"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Solution state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "@lru_cache(32)\n",
    "def schedule(jobs: Tuple[int]) -> Tuple[np.ndarray, np.ndarray]:\n",
    "    \"\"\"\n",
    "    Computes a serial schedule of the given list of jobs. See Figure 1\n",
    "    in Fleszar and Hindi (2004) for the algorithm. Returns the schedule,\n",
    "    and the resources used.\n",
    "\n",
    "    Fleszar, K. and K.S. Hindi. 2004. Solving the resource-constrained\n",
    "    project scheduling problem by a variable neighbourhood search.\n",
    "    _European Journal of Operational Research_. 155 (2): 402 -- 413.\n",
    "    \"\"\"\n",
    "    used = np.zeros((instance.duration.sum(), instance.num_resources))\n",
    "    sched = np.zeros(instance.num_jobs, dtype=int)\n",
    "\n",
    "    for job in jobs:\n",
    "        pred = instance.predecessors[job]\n",
    "        t = max(sched[pred] + instance.duration[pred], default=0)\n",
    "\n",
    "        needs = instance.needs[job]\n",
    "        duration = instance.duration[job]\n",
    "\n",
    "        # This efficiently determines the first feasible insertion point\n",
    "        # after t. We compute whether resources are available, and add the\n",
    "        # offset s of the first time sufficient are available for the\n",
    "        # duration of the job.\n",
    "        res_ok = np.all(used[t:] + needs <= instance.resources, axis=1)\n",
    "        for s in np.flatnonzero(res_ok):\n",
    "            if np.all(res_ok[s:s + duration]):\n",
    "                sched[job] = t + s\n",
    "                used[t + s:t + s + duration] += needs\n",
    "                break\n",
    "\n",
    "    return sched, used[:sched[instance.last_job]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "class RcpspState:\n",
    "    \"\"\"\n",
    "    Solution state for the resource-constrained project scheduling problem.\n",
    "\n",
    "    We use a list representation of the scheduled jobs, where job i is\n",
    "    scheduled before j if i precedes j (i.e., the jobs are sorted\n",
    "    topologically).\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, jobs: List[int]):\n",
    "        self.jobs = jobs\n",
    "        \n",
    "    def __copy__(self):\n",
    "        return RcpspState(self.jobs.copy())\n",
    "\n",
    "    @property\n",
    "    def indices(self) -> np.ndarray:\n",
    "        \"\"\"\n",
    "        Returns a mapping from job -> idx in the schedule. Unscheduled\n",
    "        jobs have index +inf.\n",
    "        \"\"\"\n",
    "        indices = np.full(instance.num_jobs, np.inf, dtype=int)\n",
    "\n",
    "        for idx, job in enumerate(self.jobs):\n",
    "            indices[job] = idx\n",
    "\n",
    "        return indices\n",
    "\n",
    "    @property\n",
    "    def unscheduled(self) -> List[int]:\n",
    "        \"\"\"\n",
    "        All jobs that are not currently scheduled, in topological order.\n",
    "        \"\"\"\n",
    "        return sorted(set(range(instance.num_jobs)) - set(self.jobs))\n",
    "\n",
    "    def objective(self) -> int:\n",
    "        s, _ = schedule(tuple(self.jobs))\n",
    "        return s[instance.last_job]\n",
    "\n",
    "    def plot(self):\n",
    "        \"\"\"\n",
    "        Plots the current schedule. The plot includes a Gantt chart, the\n",
    "        lower and upper bounds on an optimal makespan, and bar charts for\n",
    "        resource use.\n",
    "        \"\"\"\n",
    "        fig = plt.figure(figsize=(12, 6 + instance.num_resources))\n",
    "\n",
    "        hr = [1] * (instance.num_resources + 1)\n",
    "        hr[0] = 6\n",
    "\n",
    "        gs = plt.GridSpec(nrows=1 + instance.num_resources,\n",
    "                          ncols=1,\n",
    "                          height_ratios=hr)\n",
    "\n",
    "        s, u = schedule(tuple(self.jobs))\n",
    "        idcs = np.argsort(s)\n",
    "\n",
    "        gantt = fig.add_subplot(gs[0, 0])\n",
    "        gantt.axvspan(LB, UB, alpha=0.25, color='grey')\n",
    "        gantt.barh(np.arange(instance.num_jobs),\n",
    "                   instance.duration[idcs],\n",
    "                   left=s[idcs])\n",
    "\n",
    "        gantt.set_xlim(0, self.objective())\n",
    "        gantt.set_ylim(0, instance.last_job)\n",
    "        gantt.invert_yaxis()\n",
    "\n",
    "        gantt.set_title(\"Gantt chart\")\n",
    "\n",
    "        for res in range(instance.num_resources):\n",
    "            res_ax = fig.add_subplot(gs[res + 1, 0], sharex=gantt)\n",
    "            res_ax.bar(np.arange(u.shape[0]), u[:, res], align='edge')\n",
    "\n",
    "            res_ax.set_ylim(0, instance.resources[res])\n",
    "            res_ax.set_ylabel(f\"R{res + 1}\")\n",
    "\n",
    "            if res == instance.num_resources - 1:\n",
    "                res_ax.set_xlabel(\"Time\")\n",
    "\n",
    "        plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Destroy operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def most_mobile_removal(state, rnd_state):\n",
    "    \"\"\"\n",
    "    This operator unschedules those jobs that are most mobile, that is, those\n",
    "    that can be 'moved' most within the schedule, as determined by their\n",
    "    scheduled predecessors and successors. Based on Muller (2009).\n",
    "\n",
    "    Muller, LF. 2009. An Adaptive Large Neighborhood Search Algorithm\n",
    "    for the Resource-constrained Project Scheduling Problem. In _MIC\n",
    "    2009: The VIII Metaheuristics International Conference_.\n",
    "    \"\"\"\n",
    "    state = copy.copy(state)\n",
    "    indices = state.indices\n",
    "\n",
    "    # Left and right limits. These are the indices of the job's last\n",
    "    # predecessor and first successor in the schedule. That indicates\n",
    "    # the extent of the job's movement.\n",
    "    ll = np.array([np.max(indices[instance.predecessors[job]], initial=0)\n",
    "                   for job in range(instance.num_jobs)])\n",
    "\n",
    "    rl = np.array([np.min(indices[instance.successors[job]],\n",
    "                          initial=instance.num_jobs)\n",
    "                   for job in range(instance.num_jobs)])\n",
    "\n",
    "    mobility = np.maximum(rl - ll, 0)\n",
    "    mobility[[instance.first_job, instance.last_job]] = 0\n",
    "    p = mobility / mobility.sum()\n",
    "\n",
    "    for job in rnd_state.choice(instance.num_jobs, Q, replace=False, p=p):\n",
    "        state.jobs.remove(job)\n",
    "\n",
    "    return state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def non_peak_removal(state: RcpspState, rnd_state):\n",
    "    \"\"\"\n",
    "    Removes up to Q jobs that are scheduled in periods with limited resource\n",
    "    use. Those jobs might be grouped together better when they are rescheduled.\n",
    "    Based on Muller (2009).\n",
    "\n",
    "    Muller, LF. 2009. An Adaptive Large Neighborhood Search Algorithm\n",
    "    for the Resource-constrained Project Scheduling Problem. In _MIC\n",
    "    2009: The VIII Metaheuristics International Conference_.\n",
    "    \"\"\"\n",
    "    state = copy.copy(state)\n",
    "\n",
    "    start, used = schedule(tuple(state.jobs))\n",
    "    end = start + instance.duration\n",
    "\n",
    "    # Computes a measure of resource utilisation in each period, and\n",
    "    # determines periods of high resource use.\n",
    "    used = used / instance.resources\n",
    "    high_util = np.argwhere(np.mean(used, axis=1) > DELTA)\n",
    "\n",
    "    # These are all non-peak jobs, that is, jobs that are completely\n",
    "    # scheduled in periods of limited resource use.\n",
    "    jobs = [job for job in range(instance.num_jobs)\n",
    "            if np.all((high_util <= start[job]) | (high_util >= end[job]))]\n",
    "\n",
    "    for job in rnd_state.choice(jobs, min(len(jobs), Q), replace=False):\n",
    "        state.jobs.remove(job)\n",
    "\n",
    "    return state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def segment_removal(state, rnd_state):\n",
    "    \"\"\"\n",
    "    Removes a whole segment of jobs from the current solution.\n",
    "    \"\"\"\n",
    "    state = copy.copy(state)\n",
    "    offset = rnd_state.randint(1, instance.num_jobs - Q)\n",
    "\n",
    "    del state.jobs[offset:offset + Q]\n",
    "\n",
    "    return state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Repair operators\n",
    "\n",
    "We only define a single repair operator: `random_insert`.\n",
    "This operator takes the unscheduled jobs, and randomly inserts them in feasible locations in the schedule.\n",
    "Together with a justification technique (shown below) that further improves the resulting schedule, this results in a new, hopefully improved solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def justify(state):\n",
    "    \"\"\"\n",
    "    Helper method that double-justifies the schedule. Based on the\n",
    "    justification technique of Valls et al. (2005).\n",
    "\n",
    "    Valls, V. Ballestín, F. and S. Quintanilla. 2005. Jusitfication and\n",
    "    RCPSP: A technique that pays. _ European Journal of Operational\n",
    "    Research_. 165 (2): 375 -- 386.\n",
    "    \"\"\"\n",
    "    # We first right-justify the current schedule. That more or less means\n",
    "    # that we schedule jobs from the right, such that no job can be started\n",
    "    # later without increases the makespan.\n",
    "    makespan = state.objective()\n",
    "    used = np.zeros((makespan, instance.num_resources))\n",
    "    sched = np.zeros(instance.num_jobs, dtype=int)\n",
    "\n",
    "    for job in reversed(state.jobs):\n",
    "        needs = instance.needs[job]\n",
    "        duration = instance.duration[job]\n",
    "\n",
    "        t = min(sched[instance.successors[job]], default=makespan)\n",
    "        res_ok = np.all(used[:t] + needs <= instance.resources, axis=1)\n",
    "\n",
    "        for s in reversed(np.flatnonzero(res_ok[:t - duration + 1])):\n",
    "            if np.all(res_ok[s:s + duration]):\n",
    "                sched[job] = s\n",
    "                used[s:s + duration, :] += needs\n",
    "                break\n",
    "\n",
    "    # Right-justify the schedule, and then left-justify it again. This\n",
    "    # results in a double-justified schedule that is hopefully better\n",
    "    # than what we got initially.\n",
    "    right_justified = np.argsort(sched)\n",
    "    sched, _ = schedule(tuple(right_justified))\n",
    "    left_justified = np.argsort(sched).tolist()\n",
    "\n",
    "    return RcpspState(left_justified)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def random_insert(state, rnd_state):\n",
    "    \"\"\"\n",
    "    Randomly inserts jobs into the schedule. The resulting solution state\n",
    "    is guaranteed to be feasible.\n",
    "    \"\"\"\n",
    "    indices = state.indices\n",
    "    preds = instance.all_predecessors\n",
    "    succs = instance.all_successors\n",
    "\n",
    "    for job in state.unscheduled:\n",
    "        # Left and right insertion limits. The job must be inserted\n",
    "        # between these indices - the interval is [ll, rl).\n",
    "        ll = np.max(indices[preds[job]], initial=-1) + 1\n",
    "        rl = np.min(indices[succs[job]], initial=len(state.jobs))\n",
    "\n",
    "        idx = rnd_state.randint(ll, rl) if ll < rl else ll\n",
    "        state.jobs.insert(idx, job)\n",
    "\n",
    "        indices[indices >= idx] += 1\n",
    "        indices[job] = idx\n",
    "\n",
    "    return justify(state)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Initial solution\n",
    "\n",
    "Our solution representation is a list of jobs.\n",
    "We can thus easily generate an initial solution as the list of all jobs, in the (topological) order we got them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial solution has objective 172.\n"
     ]
    }
   ],
   "source": [
    "init_sol = RcpspState(list(range(instance.num_jobs)))\n",
    "print(f\"Initial solution has objective {init_sol.objective()}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x1000 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "init_sol.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Heuristic solution\n",
    "\n",
    "With our initial solution in hand, we can now use ALNS to further improve it.\n",
    "We use a segmented roulette wheel operator selection strategy, and a simple hill-climbing acceptance criterion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "rnd_state = rnd.RandomState(SEED)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "alns = ALNS(rnd_state)\n",
    "\n",
    "alns.add_destroy_operator(most_mobile_removal)\n",
    "alns.add_destroy_operator(non_peak_removal)\n",
    "alns.add_destroy_operator(segment_removal)\n",
    "\n",
    "alns.add_repair_operator(random_insert)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Heuristic solution has objective 141.\n"
     ]
    }
   ],
   "source": [
    "select = SegmentedRouletteWheel(WEIGHTS, THETA, SEG_LENGTH, 3, 1)\n",
    "accept = HillClimbing()\n",
    "stop = MaxIterations(ITERS)\n",
    "\n",
    "res = alns.iterate(init_sol, select, accept, stop)\n",
    "sol = res.best_state\n",
    "\n",
    "print(f\"Heuristic solution has objective {sol.objective()}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_, ax = plt.subplots(figsize=(12, 6))\n",
    "res.plot_objectives(ax=ax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x1000 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sol.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Conclusion\n",
    "\n",
    "In this notebook we solved a challenging instance of the resource-constrained project scheduling problem, using several operators and enhancement techniques from the literature.\n",
    "The resulting heuristic solution is competitive with other heuristics for this problem: the best known solution achieves a makespan of 135, and we find 141, just 4% higher."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}