Notebook Test - Tino.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Projet Recherche Opérationelle - Branch And Bound"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importation des modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import math\n",
    "import copy\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Structure de données"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node:\n",
    "    \n",
    "    def __init__(self,idx, parent, children, lb, visited):\n",
    "        self.idx = idx\n",
    "        self.parent = parent\n",
    "        self.children = children\n",
    "        self.lb = lb\n",
    "        self.visited = visited\n",
    "        \n",
    "    def __str__(self):\n",
    "        return (\"\\n Index : \" +str(self.idx)+\n",
    "                \"\\n Parent : \" +str(self.parent)+\n",
    "                \"\\n Children : \"+str(self.children) + \n",
    "                \"\\n lb : \"+str(self.lb)+ \n",
    "                \"\\n visited : \"+str(self.visited))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def arborescence(node,Tree):\n",
    "    branch = []\n",
    "    while node.parent != None:\n",
    "        branch.append(node)\n",
    "        node = Tree[node.parent]\n",
    "    branch.append(node)\n",
    "    \n",
    "    return branch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Textbook Example\n",
    "pj = [12,8,15,9]\n",
    "dj = [16,26,25,27]\n",
    "wj = [4,5,3,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def computeCost(p,d,w,order):\n",
    "    t=0\n",
    "    cost=0\n",
    "    for idx in order:\n",
    "        t += p[idx]\n",
    "        cost += max(0,(t-d[idx])*w[idx])\n",
    "    return cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "67"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "computeCost(pj,dj,wj,[0,1,3,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getPrimal_0(p,d,w):\n",
    "    sortedTasks=(np.argsort((np.array(d)-np.array(p))*np.array(w)))[::-1]\n",
    "    cost=computeCost(p,d,w,sortedTasks)\n",
    "    return(cost,sortedTasks)\n",
    "\n",
    "def getPrimal_1(p,d,w):\n",
    "    sortedTasks=np.argsort(d)\n",
    "    cost=computeCost(p,d,w,sortedTasks)\n",
    "    return(cost,sortedTasks)\n",
    "\n",
    "def getPrimal_2(p,d,w):\n",
    "    tasksLeft=[int(i) for i in range(len(p))]\n",
    "    order=[]\n",
    "    while len(tasksLeft)!= 0:\n",
    "        time=np.sum(np.array(p)[tasksLeft])\n",
    "        penalities=(time-np.array(d)[tasksLeft])*np.array(w)[tasksLeft]\n",
    "        sortedTasks=np.argsort(penalities)\n",
    "        order.append(tasksLeft[sortedTasks[0]])\n",
    "        tasksLeft.pop(sortedTasks[0])\n",
    "    order.reverse()\n",
    "    cost = computeCost(p,d,w,order)\n",
    "    return(cost,order)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Temps production :  [12, 8, 15, 9]\n",
      "Date limite :       [16, 26, 25, 27]\n",
      "Pénalités :         [4, 5, 3, 5]\n",
      "0 :  (133, array([3, 1, 2, 0], dtype=int64))\n",
      "1 :  (136, array([0, 2, 1, 3], dtype=int64))\n",
      "2 :  (67, [0, 1, 3, 2])\n"
     ]
    }
   ],
   "source": [
    "print(\"Temps production : \", pj)\n",
    "print(\"Date limite :      \", dj)\n",
    "print(\"Pénalités :        \", wj)\n",
    "print(\"0 : \",getPrimal_0(pj,dj,wj))\n",
    "print(\"1 : \",getPrimal_1(pj,dj,wj))\n",
    "print(\"2 : \",getPrimal_2(pj,dj,wj))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getDual_0(p,d,w,visited):\n",
    "    dual=0\n",
    "    time=0\n",
    "    notVisited=list(range(len(p)))\n",
    "    for i in visited:\n",
    "        retard=((p[i]+time)-d[i])\n",
    "        dual+=retard*w[i]*(retard>0)\n",
    "        time+=p[i]\n",
    "        notVisited.remove(i)\n",
    "        \n",
    "    for j in notVisited:\n",
    "        retard=(p[j]+time)-d[j]\n",
    "        dual+=retard*w[j]*(retard>0)\n",
    "    return dual\n",
    "\n",
    "def getDual_1(p,d,w,visited):\n",
    "    dual=0\n",
    "    time=0\n",
    "    notVisited=list(range(len(p)))\n",
    "    for i in visited:\n",
    "        retard=((p[i]+time)-d[i])\n",
    "        dual+=retard*w[i]*(retard>0)\n",
    "        time+=p[i]\n",
    "        notVisited.remove(i)\n",
    "        \n",
    "    return dual\n",
    "\n",
    "def getDual_2(p,d,w,visited):\n",
    "    dual=0\n",
    "    time=np.sum(p)\n",
    "\n",
    "    for i in visited:\n",
    "        retard=(time-d[i])\n",
    "        dual+=retard*w[i]*(retard>0)\n",
    "        time-=p[i]\n",
    "        \n",
    "    return dual"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Si on a fixé l'ordre de k pièces on calcule les pénalités de retard de ces k pièces et on ajoute les pénalités des autres pièces en supposant qu'elles sont en (k+1)ème position : \n",
      " 110\n",
      "Si on a fixé l'ordre de k pièces on calcule les pénalités de retard de ces k pièces : \n",
      " 0\n"
     ]
    }
   ],
   "source": [
    "print(\"Si on a fixé l'ordre de k pièces on calcule les pénalités de retard de ces k pièces et on ajoute les pénalités des autres pièces en supposant qu'elles sont en (k+1)ème position : \\n\",\n",
    "      getDual_0(pj,dj,wj,[2,3]))\n",
    "print(\"Si on a fixé l'ordre de k pièces on calcule les pénalités de retard de ces k pièces : \\n\",\n",
    "      getDual_1(pj,dj,wj,[2,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def exploration_0(Queue,Tree,UB):\n",
    "    return(Queue[0])\n",
    "\n",
    "def exploration_1(Queue,Tree,UB):\n",
    "    return(Queue[-1])\n",
    "\n",
    "def exploration_2(Queue,Tree,UB):\n",
    "    bestNode = None\n",
    "    bestLB = -math.inf\n",
    "    for i in range(len(Queue)):\n",
    "        if Tree[Queue[i]].lb > bestLB and Tree[Queue[i]].lb < UB:\n",
    "            bestLB = Tree[Queue[i]].lb\n",
    "            bestNode = i\n",
    "    return(Queue[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Branch and Bound"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def branch_and_bound_display(p,d,w,byLast,getPrimal,getDual,exploration,steps):\n",
    "    \n",
    "    Tasks = list(range(len(p)))\n",
    "    Tree = [] # list of all nodes created (a list of Node objects)\n",
    "    Queue = [] # list of nodes to process (a list of integers with the index of nodes to process in the Tree)\n",
    "    UB = 10000000 # set the upper bound to a sufficiently large number\n",
    "    LB = 0 # set the lower bound to a sufficiently small number \n",
    "    \n",
    "    UB,currentOrder = getPrimal(p,d,w)\n",
    "    if steps:\n",
    "        print(\"First UB : \", UB)\n",
    "    \n",
    "    root = Node(0,None, [], 0, []) # at the root node no variables are fixed \n",
    "    Tree.append(root) # start the tree with the root node\n",
    "    Queue.append(0) # start the list of nodes to process with the root node\n",
    "    \n",
    "    #continue processing nodes until the queue is empty\n",
    "    \n",
    "    nbIterations = 0\n",
    "    \n",
    "    while Queue!=[]:\n",
    "        \n",
    "\n",
    "        # process the first node in the queue\n",
    "\n",
    "        currentIndex = exploration(Queue,Tree,UB)\n",
    "        currentNode = Tree[currentIndex]\n",
    "        nbIterations +=1\n",
    "        \n",
    "        if nbIterations == 1e4:\n",
    "            print(\"UB : \", UB)\n",
    "            print(currentNode)\n",
    "        if nbIterations == 2e5:\n",
    "            print(\"UB : \", UB)\n",
    "            print(currentNode)\n",
    "        if nbIterations == 2e5:\n",
    "            print(\"UB : \", UB)\n",
    "            print(currentNode)\n",
    "        \n",
    "        if steps:\n",
    "            print(\"##################################\")\n",
    "            print(\"Current Node : {}\\n\".format(currentIndex),currentNode )\n",
    "        \n",
    "        if len(currentNode.visited) == len(p):\n",
    "            order = copy.copy(currentNode.visited)\n",
    "            if byLast:\n",
    "                order.reverse()\n",
    "            solutionCost = computeCost(p,d,w,order)\n",
    "            if solutionCost <= UB:\n",
    "                UB = solutionCost\n",
    "                currentOrder=order\n",
    "                \n",
    "        if currentNode.lb < UB:\n",
    "            for nextTask in (set(Tasks)-set(currentNode.visited)):\n",
    "                nextVisited = copy.copy(currentNode.visited)\n",
    "                nextVisited.append(nextTask)\n",
    "                nextLb = getDual(p,d,w, nextVisited)\n",
    "                \n",
    "                newNode = Node(len(Tree)-1,currentIndex, [], nextLb,nextVisited)\n",
    "                Tree.append(newNode)\n",
    "                Queue.append(len(Tree)-1)\n",
    "                currentNode.children.append(len(Tree)-1)\n",
    "        else:\n",
    "            if steps:\n",
    "                print(\"Prune : \", currentIndex)\n",
    "        \n",
    "        # Calculate the current LB as the maximum of all the upper bounds among the active nodes\n",
    "        currentLB = -math.inf\n",
    "        for node in Tree:\n",
    "            if node.lb > currentLB and node.lb <= UB:\n",
    "                currentLB = node.lb\n",
    "        \n",
    "        # Update the LB if the current LB is better\n",
    "        if currentLB >= LB:\n",
    "            LB = currentLB\n",
    "        \n",
    "        # Display the current upper and lower bounds    \n",
    "        if steps:\n",
    "            print(\"LB= \",LB,\" UB= \", UB)\n",
    "        # When the processing of the node is completed remove the node from the queue     \n",
    "        Queue.remove(currentIndex)\n",
    "\n",
    "    # return the  solution\n",
    "    print(\"Number of iterations : \", nbIterations)\n",
    "    \n",
    "    return UB, currentOrder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def branch_and_bound(p,d,w,byLast,getPrimal,getDual,exploration):\n",
    "    \n",
    "    Tasks = list(range(len(p)))\n",
    "    Tree = [] # list of all nodes created (a list of Node objects)\n",
    "    Queue = [] # list of nodes to process (a list of integers with the index of nodes to process in the Tree)\n",
    "    UB = 10000000 # set the upper bound to a sufficiently large number\n",
    "    LB = 0 # set the lower bound to a sufficiently small number \n",
    "    \n",
    "    UB,currentOrder = getPrimal(p,d,w)\n",
    "\n",
    "    bestNode = Node(-1,-1, [], 0 ,[])\n",
    "    \n",
    "    root = Node(0,None, [], 0, []) # at the root node no variables are fixed \n",
    "    Tree.append(root) # start the tree with the root node\n",
    "    Queue.append(0) # start the list of nodes to process with the root node\n",
    "    \n",
    "    #continue processing nodes until the queue is empty\n",
    "    \n",
    "    nbIterations = 0\n",
    "    \n",
    "    while Queue!=[]:\n",
    "        \n",
    "        # process the first node in the queue\n",
    "\n",
    "        currentIndex = exploration(Queue,None,None)\n",
    "        currentNode = Tree[currentIndex]\n",
    "        nbIterations +=1\n",
    "        \n",
    "        if currentNode.lb < UB:\n",
    "            \n",
    "            if len(currentNode.visited) == len(p):\n",
    "                order = copy.copy(currentNode.visited)\n",
    "                if byLast:\n",
    "                    order.reverse()\n",
    "                solutionCost = computeCost(p,d,w,order)\n",
    "                if solutionCost <= UB:\n",
    "                    UB = solutionCost\n",
    "                    currentOrder=order\n",
    "                    bestNode = currentNode\n",
    "            else:\n",
    "                for nextTask in (set(Tasks)-set(currentNode.visited)):\n",
    "                    nextVisited = copy.copy(currentNode.visited)\n",
    "                    nextVisited.append(nextTask)\n",
    "                    nextLb = getDual(p,d,w, nextVisited)\n",
    "\n",
    "                    newNode = Node(len(Tree),currentIndex, [], nextLb,nextVisited)\n",
    "                    Tree.append(newNode)\n",
    "                    Queue.append(len(Tree)-1)\n",
    "                    currentNode.children.append(len(Tree)-1)\n",
    "            \n",
    "        # When the processing of the node is completed remove the node from the queue     \n",
    "        Queue.remove(currentIndex)\n",
    "\n",
    "    # return the  solution\n",
    "    \n",
    "    if 2*(UB-bestNode.lb)/(UB+bestNode.lb)<=0.0001:\n",
    "        branch = arborescence(bestNode,Tree)\n",
    "    else:\n",
    "        bestLB = -math.inf\n",
    "        for node in Tree:\n",
    "            if node.lb > bestLB and node.lb <=UB:\n",
    "                bestLB = node.lb\n",
    "                bestNode=node\n",
    "        branch = arborescence(bestNode,Tree)\n",
    "\n",
    "    return UB, currentOrder, nbIterations, branch, Tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Textbook Example\n",
    "pj = [12,8,15,9]\n",
    "dj = [16,26,25,27]\n",
    "wj = [4,5,3,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "65\n",
      "59\n",
      "44\n",
      "17\n",
      "38\n",
      "17\n",
      "8\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "solution, order, nbIterations, branch, Tree = branch_and_bound(pj,dj,wj, False, getPrimal_1, getDual_1,exploration_1)\n",
    "print(nbIterations)\n",
    "solution, order, nbIterations, branch, Tree = branch_and_bound(pj,dj,wj, False, getPrimal_2, getDual_1,exploration_1)\n",
    "print(nbIterations)\n",
    "solution, order, nbIterations, branch, Tree = branch_and_bound(pj,dj,wj, True, getPrimal_1, getDual_2,exploration_0)\n",
    "print(nbIterations)\n",
    "solution, order, nbIterations, branch, Tree = branch_and_bound(pj,dj,wj, True, getPrimal_1, getDual_2,exploration_1)\n",
    "print(nbIterations)\n",
    "solution, order, nbIterations, branch, Tree = branch_and_bound(pj,dj,wj, True, getPrimal_0, getDual_2,exploration_0)\n",
    "print(nbIterations)\n",
    "solution, order, nbIterations, branch, Tree = branch_and_bound(pj,dj,wj, True, getPrimal_0, getDual_2,exploration_1)\n",
    "print(nbIterations)\n",
    "solution, order, nbIterations, branch, Tree = branch_and_bound(pj,dj,wj, True, getPrimal_2, getDual_2,exploration_0)\n",
    "print(nbIterations)\n",
    "solution, order, nbIterations, branch, Tree = branch_and_bound(pj,dj,wj, True, getPrimal_2, getDual_2,exploration_1)\n",
    "print(nbIterations)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test de notre fonction Branch-And-Bound : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def genInstancies(n):\n",
    "    p=np.random.randint(1,15,n)\n",
    "    d=np.random.randint(3,int(0.5*n*15),n)\n",
    "    w=np.random.randint(1,5,n)\n",
    "    return(p,d,w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p :  [ 9  9  2 10]\n",
      "d :  [19 18 20 16]\n",
      "w :  [1 3 4 3]\n",
      "Final Results: 10 Iterations\n",
      "Order : [3, 1, 2, 0] | Cost : 18\n"
     ]
    }
   ],
   "source": [
    "p,d,w = genInstancies(4)\n",
    "print(\"p : \", p)\n",
    "print(\"d : \", d)\n",
    "print(\"w : \", w)\n",
    "solution, order, nbIterations, branch, tree = branch_and_bound(p,d,w, True, getPrimal_2, getDual_2,exploration_1)\n",
    "print(\"Final Results: {} Iterations\".format(nbIterations))\n",
    "print(\"Order : {} | Cost : {}\".format(order,computeCost(p,d,w,order)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<__main__.Node at 0x277b0f08988>,\n",
       " <__main__.Node at 0x277b0f08f48>,\n",
       " <__main__.Node at 0x277b0f08a88>,\n",
       " <__main__.Node at 0x277b0f08a08>]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "branch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pydot\n",
    "from networkx.drawing.nx_pydot import graphviz_layout\n",
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Textbook Example\n",
    "pj = [12,8,15,9]\n",
    "dj = [16,26,25,27]\n",
    "wj = [4,5,3,5]\n",
    "solution, order, nbIterations, branch, tree = branch_and_bound(pj,dj,wj, True, getPrimal_2, getDual_2,exploration_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "index = [node.idx for node in tree]\n",
    "mygraph=nx.Graph()\n",
    "mygraph.add_nodes_from(index)\n",
    "\n",
    "for node in tree:\n",
    "    if node.parent != None:\n",
    "        mygraph.add_edge(node.idx, node.parent)\n",
    "\n",
    "    \n",
    "plt.figure(figsize=(12,8))\n",
    "pos = graphviz_layout(mygraph, prog=\"dot\")\n",
    "nx.draw(mygraph, pos,with_labels=True,node_size=1200,node_color=\"lightblue\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15 15 15\n"
     ]
    }
   ],
   "source": [
    "pt = [12,8,15,9,12,14,5,9,8,14,2,6,8,1,1]\n",
    "dt = [16,26,25,27,45,88,70,12,33,55,44,13,91,42,81]\n",
    "wt = [4,5,3,5,1,2,3,4,5,1,2,3,4,5,1]\n",
    "print(len(pt),len(dt),len(wt))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "85.93007063865662\n"
     ]
    }
   ],
   "source": [
    "start = time.time()\n",
    "solution, order, nbIterations, branch, tree = branch_and_bound(pt,dt,wt, True, getPrimal_2, getDual_2,exploration_1)\n",
    "end = time.time()\n",
    "time1 = end-start\n",
    "print(time1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test d'efficacité"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node:\n",
    "    \n",
    "    def __init__(self,idx, parent, children, lb, visited):\n",
    "        self.idx = idx\n",
    "        self.parent = parent\n",
    "        self.children = children\n",
    "        self.lb = lb\n",
    "        self.visited = visited\n",
    "        \n",
    "    def __str__(self):\n",
    "        return (\"Parent : \" +str(self.parent)+\n",
    "                \"\\n Children : \"+str(self.children) + \n",
    "                \"\\n lb : \"+str(self.lb)+ \n",
    "                \"\\n visited : \"+str(self.visited))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def arborescence(node,Tree):\n",
    "    branch = []\n",
    "    while node.parent != None:\n",
    "        branch.append(node.idx)\n",
    "        node = node.parent\n",
    "    branch.append(node.idx)\n",
    "    \n",
    "    return branch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def branch_and_bound(p,d,w,byLast,getPrimal,getDual,exploration):\n",
    "    \n",
    "    Tasks = list(range(len(p)))\n",
    "    Tree = [] # list of all nodes created (a list of Node objects)\n",
    "    Queue = [] # list of nodes to process (a list of integers with the index of nodes to process in the Tree)\n",
    "    UB = 10000000 # set the upper bound to a sufficiently large number\n",
    "    LB = 0 # set the lower bound to a sufficiently small number \n",
    "    \n",
    "    UB,currentOrder = getPrimal(p,d,w)\n",
    "\n",
    "    bestNode = Node(\"\",-1, [], 0 ,[])\n",
    "    \n",
    "    root = Node(\"P\",None, [], 0, []) # at the root node no variables are fixed \n",
    "    Tree.append(root) # start the tree with the root node\n",
    "    Queue.append(0) # start the list of nodes to process with the root node\n",
    "    \n",
    "    #continue processing nodes until the queue is empty\n",
    "    \n",
    "    nbIterations = 0\n",
    "    \n",
    "    while Queue!=[]:\n",
    "        \n",
    "        # process the first node in the queue\n",
    "\n",
    "        currentIndex = exploration(Queue,None,None)\n",
    "        currentNode = Tree[currentIndex]\n",
    "        nbIterations +=1\n",
    "        \n",
    "        if currentNode.lb < UB:\n",
    "            \n",
    "            if len(currentNode.visited) == len(p):\n",
    "                order = currentNode.visited.copy()\n",
    "                if byLast:\n",
    "                    order.reverse()\n",
    "                solutionCost = computeCost(p,d,w,order)\n",
    "                if solutionCost <= UB:\n",
    "                    UB = solutionCost\n",
    "                    currentOrder=order\n",
    "                    bestNode = currentNode\n",
    "            else:\n",
    "                for nextTask in (set(Tasks)-set(currentNode.visited)):\n",
    "                    nextVisited = currentNode.visited.copy()\n",
    "                    nextVisited.append(nextTask)\n",
    "                    nextLb = getDual(p,d,w, nextVisited)\n",
    "\n",
    "                    newNode = Node(\"\",currentNode, [], nextLb,nextVisited)\n",
    "                    \n",
    "                    if currentNode.visited!=[]:\n",
    "                        newNode.idx=\"P(\"+str(nextTask)+\",\"+str(currentNode.visited[len(currentNode.visited)-1])+\")\"\n",
    "                    else:\n",
    "                        newNode.idx=\"P(\"+str(nextTask)+\")\"\n",
    "                        \n",
    "                    Tree.append(newNode)\n",
    "                    Queue.append(len(Tree)-1)\n",
    "                    currentNode.children.append(newNode)\n",
    "            \n",
    "        # When the processing of the node is completed remove the node from the queue     \n",
    "        Queue.remove(currentIndex)\n",
    "\n",
    "    # return the  solution\n",
    "    \n",
    "    if 2*(UB-bestNode.lb)/(UB+bestNode.lb)<=0.0001:\n",
    "        branch = arborescence(bestNode,Tree)\n",
    "    else:\n",
    "        bestLB = -math.inf\n",
    "        for node in Tree:\n",
    "            if node.lb > bestLB and node.lb <=UB:\n",
    "                bestLB = node.lb\n",
    "                bestNode=node\n",
    "        branch = arborescence(bestNode,Tree)\n",
    "\n",
    "    return UB, currentOrder, nbIterations, branch, Tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "86.69789671897888\n"
     ]
    }
   ],
   "source": [
    "start = time.time()\n",
    "solution, order, nbIterations, branch, tree = branch_and_bound(pt,dt,wt, True, getPrimal_2, getDual_2,exploration_1)\n",
    "end = time.time()\n",
    "time2 = end-start\n",
    "print(time2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.893547595871346"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "100*(time2-time1)/time1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def branch_and_bound(p,d,w,byLast,getPrimal,getDual,exploration):\n",
    "    \n",
    "    Tasks = list(range(len(p)))\n",
    "    Tree = [] # list of all nodes created (a list of Node objects)\n",
    "    Queue = [] # list of nodes to process (a list of integers with the index of nodes to process in the Tree)\n",
    "    UB = 10000000 # set the upper bound to a sufficiently large number\n",
    "    LB = 0 # set the lower bound to a sufficiently small number \n",
    "    \n",
    "    UB,currentOrder = getPrimal(p,d,w)\n",
    "\n",
    "    bestNode = Node(\"\",-1, [], 0 ,[])\n",
    "    \n",
    "    root = Node(\"P\",None, [], 0, []) # at the root node no variables are fixed \n",
    "    Tree.append(root) # start the tree with the root node\n",
    "    Queue.append(0) # start the list of nodes to process with the root node\n",
    "    \n",
    "    #continue processing nodes until the queue is empty\n",
    "    \n",
    "    nbIterations = 0\n",
    "    \n",
    "    while Queue!=[]:\n",
    "        \n",
    "        # process the first node in the queue\n",
    "\n",
    "        currentIndex = exploration(Queue,None,None)\n",
    "        currentNode = Tree[currentIndex]\n",
    "        nbIterations +=1\n",
    "        \n",
    "        if currentNode.lb < UB:\n",
    "            \n",
    "            if len(currentNode.visited) == len(p):\n",
    "                order = currentNode.visited.copy()\n",
    "                if byLast:\n",
    "                    order.reverse()\n",
    "                solutionCost = computeCost(p,d,w,order)\n",
    "                if solutionCost <= UB:\n",
    "                    UB = solutionCost\n",
    "                    currentOrder=order\n",
    "                    bestNode = currentNode\n",
    "            else:\n",
    "                for nextTask in (set(Tasks)-set(currentNode.visited)):\n",
    "                    nextVisited = currentNode.visited.copy()\n",
    "                    nextVisited.append(nextTask)\n",
    "                    nextLb = getDual(p,d,w, nextVisited)\n",
    "\n",
    "                    newNode = Node(\"\",currentNode, [], nextLb,nextVisited)\n",
    "                    \n",
    "                    if currentNode.visited!=[]:\n",
    "#                        newNode.idx=\"P(\"+str(nextTask)+\",\"+str(currentNode.visited[len(currentNode.visited)-1])+\")\"\n",
    "                         newNode.idx=\"P(\"\n",
    "                         for i in range(len(nextVisited)-1):\n",
    "                             newNode.idx+=str(nextVisited[i])+\",\"\n",
    "                         newNode.idx+=str(nextVisited[len(nextVisited)-1])+\")\"\n",
    "                    else:\n",
    "                        newNode.idx=\"P(\"+str(nextTask)+\")\"\n",
    "                        \n",
    "                    Tree.append(newNode)\n",
    "                    Queue.append(len(Tree)-1)\n",
    "                    currentNode.children.append(newNode)\n",
    "            \n",
    "        # When the processing of the node is completed remove the node from the queue     \n",
    "        Queue.remove(currentIndex)\n",
    "\n",
    "    # return the  solution\n",
    "    \n",
    "    if 2*(UB-bestNode.lb)<=0.0001:\n",
    "        branch = arborescence(bestNode,Tree)\n",
    "    else:\n",
    "        bestLB = -math.inf\n",
    "        for node in Tree:\n",
    "            if node.lb > bestLB and node.lb <=UB:\n",
    "                bestLB = node.lb\n",
    "                bestNode=node\n",
    "        branch = arborescence(bestNode,Tree)\n",
    "\n",
    "    return UB, currentOrder, nbIterations, branch, Tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "86.69789671897888\n"
     ]
    }
   ],
   "source": [
    "start = time.time()\n",
    "solution, order, nbIterations, branch, tree = branch_and_bound(pt,dt,wt, True, getPrimal_2, getDual_2,exploration_1)\n",
    "end = time.time()\n",
    "time3 = end-start\n",
    "print(time2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.96515497434902"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "100*(time3-time1)/time1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def displayTree(Tree,currentOrder,branch,byLast):\n",
    "    \n",
    "    index=['P']\n",
    "    parent=['P']\n",
    "    for node in Tree:\n",
    "        if(node.idx!=\"P\"):\n",
    "            index.append(node.idx)\n",
    "            parent.append((node.parent).idx)\n",
    "    graphe=dict(zip(index,parent))\n",
    "    \n",
    "    graph=nx.Graph()\n",
    "    graph.add_nodes_from(index)\n",
    "    for idx in graphe.keys():\n",
    "        graph.add_edge(idx,graphe[idx])\n",
    "        \n",
    "    if(byLast==True):\n",
    "        branch.reverse()\n",
    "\n",
    "    bestPath= set(zip(branch[:-1], branch[1:]))\n",
    "    edge_colors=dict()\n",
    "    for edge in graph.edges():\n",
    "        if edge in bestPath:\n",
    "            edge_colors[edge]='red'\n",
    "        else:\n",
    "            edge_colors[edge]='lightblue'\n",
    "            \n",
    "    node_colors=dict()\n",
    "    for node in graph.nodes():\n",
    "        if node in branch:\n",
    "            node_colors[node]='red'\n",
    "        else:\n",
    "            node_colors[node]=\"lightblue\"\n",
    "    \n",
    "    plt.figure(figsize=(12,8))\n",
    "    pos = graphviz_layout(graph, prog=\"dot\")\n",
    "    nx.draw(graph, pos,with_labels=True,node_size=1200,node_color=node_colors.values(),edge_color=edge_colors.values())\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Textbook Example\n",
    "pj = [12,8,15,9]\n",
    "dj = [16,26,25,27]\n",
    "wj = [4,5,3,5]\n",
    "\n",
    "solution,order,nbIterations,branch,Tree=branch_and_bound(pj,dj,wj, True, getPrimal_2, getDual_2,exploration_0)\n",
    "displayTree(Tree,order,branch,True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Depth First\n",
      "                  0 | 2\n",
      "Solution       : 312 | 312\n",
      "nbIterations   : 5182 | 584\n",
      "Execution time : 0.03600811958312988 | 0.014002799987792969\n",
      "\n",
      "Breadth First\n",
      "                  0 | 2\n",
      "Solution       : 312 | 312\n",
      "nbIterations   : 11719 | 2460\n",
      "Execution time : 0.09002065658569336 | 0.07901763916015625\n"
     ]
    }
   ],
   "source": [
    "d = [22, 39, 31, 28, 24, 37, 32, 20] \n",
    "w = [2, 8, 5, 3, 6, 3, 4, 7]\n",
    "p = [16, 17, 10, 5, 2, 4, 3, 18]\n",
    "\n",
    "print(\"Depth First\")\n",
    "start1 = time.time()\n",
    "solution_0, order_0, nbIterations_0, branch_0, Tree = branch_and_bound(p,d,w, False, getPrimal_2, getDual_0,exploration_1)\n",
    "end1 = time.time()\n",
    "start = time.time()\n",
    "solution_2, order_2, nbIterations_2, branch_2, Tree = branch_and_bound(p,d,w, True, getPrimal_2, getDual_2,exploration_1)\n",
    "end = time.time()\n",
    "print(\"                  0 | 2\")\n",
    "print(\"Solution       : {} | {}\".format(solution_0,solution_2))\n",
    "print(\"nbIterations   : {} | {}\".format(nbIterations_0,nbIterations_2))\n",
    "print(\"Execution time : {} | {}\".format(end1-start1,end-start))\n",
    "\n",
    "print(\"\\nBreadth First\")\n",
    "start1 = time.time()\n",
    "solution_0, order_0, nbIterations_0, branch_0, Tree = branch_and_bound(p,d,w, False, getPrimal_2, getDual_0,exploration_0)\n",
    "end1 = time.time()\n",
    "start = time.time()\n",
    "solution_2, order_2, nbIterations_2, branch_2, Tree = branch_and_bound(p,d,w, True, getPrimal_2, getDual_2,exploration_0)\n",
    "end = time.time()\n",
    "print(\"                  0 | 2\")\n",
    "print(\"Solution       : {} | {}\".format(solution_0,solution_2))\n",
    "print(\"nbIterations   : {} | {}\".format(nbIterations_0,nbIterations_2))\n",
    "print(\"Execution time : {} | {}\".format(end1-start1,end-start))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}