Graph-theory-algorithms-with-Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "<strong>Université Chouaïb Doukkali<br>",
    "Faculté des Sciences d’El Jadida <br>",
    "    Département d’Informatique<br></strong><br>",
    "<img src=\"fs.png\"  height=\"110\" width=\"110\">",
    "<br><br>",
    "<div align=\"center\"> <h1>Implementation of graph theory algorithms from scratch using python</h1></div>",
    "<br><br><br>",
    "<div align=\"left\"><strong>Realized by: AGHEZZAF Mohamed</strong></div>  <div align=\"right\"><strong> Framed by: Pr. Ahmed AZOUAOUI</strong></div><br><br><br>",
    "<div align=\"center\"><strong>Module: GRAPH THEORY</strong></div><br>",
    "<div align=\"center\">College year : 2018-2019</div><br><br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pydot\n",
    "from IPython.display import Image, display"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Creating a graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Give the size of the graph: 4\n",
      "Give the type of graph: (type 1 if the graph is oriented, 0 otherwise)\n",
      "0\n",
      "Give the initial end of the arc/edge A\n",
      "Give the final end of the arc/edge \n",
      "B\n",
      "Give the initial end of the arc/edge B\n",
      "Give the final end of the arc/edge \n",
      "C\n",
      "Give the initial end of the arc/edge C\n",
      "Give the final end of the arc/edge \n",
      "D\n",
      "Give the initial end of the arc/edge D\n",
      "Give the final end of the arc/edge \n",
      "B\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['AB', 'BC', 'CD', 'DB']"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#List of summits\n",
    "G = dict()\n",
    "#Get the graph size \n",
    "taille = input(\"Give the size of the graph: \")\n",
    "#Retrieve the type of graph\n",
    "print(\"Give the type of graph: (type 1 if the graph is oriented, 0 otherwise)\")\n",
    "genre = input()\n",
    "\n",
    "for i in range(int(taille)):\n",
    "    a=input(\"Give the initial end of the arc/edge \")\n",
    "    b=input(\"Give the final end of the arc/edge \\n\")\n",
    "    if(a not in G):\n",
    "        G[a]=[]\n",
    "    G[a].append(b)\n",
    "    \n",
    "def Sommets(G):\n",
    "    S=set()\n",
    "    for i in G:\n",
    "        S.add(i)\n",
    "        for j in G[i]:\n",
    "            S.add(j)\n",
    "    return sorted(S)\n",
    "\n",
    "def Arcs(G):\n",
    "    A=set()\n",
    "    for i in G:\n",
    "        for j in G[i]:\n",
    "            A.add(i+j)\n",
    "    return sorted(A)\n",
    "Sommets(G)\n",
    "Arcs(G)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Display of a graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def TraceG(G,genre):\n",
    "    if(genre==\"0\"):\n",
    "        graph=pydot.Dot(graph_type=\"graph\")\n",
    "\n",
    "    elif genre==\"1\":\n",
    "        graph=pydot.Dot(graph_type=\"digraph\")\n",
    "    for i in G:    \n",
    "        node=pydot.Node(i)\n",
    "        graph.add_node(node)\n",
    "        for j in G[i]:\n",
    "            arc=pydot.Edge(i,j)\n",
    "            graph.add_edge(arc)\n",
    "    img=Image(graph.create_png())\n",
    "    display(img)\n",
    "\n",
    "TraceG(G,genre)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Summit predecessor and successor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Give a vertex B\n",
      "Pred( B ) =  ['A', 'D', 'C']\n",
      "Succ( B ) =  ['C', 'A', 'D']\n"
     ]
    }
   ],
   "source": [
    "#The set of vertex predecessors x\n",
    "def Pred(G,sommet,genre):\n",
    "    list=[]\n",
    "    if(genre==\"1\"):\n",
    "        for i in G:    \n",
    "            for j in G[i]:\n",
    "                if (j==sommet):\n",
    "                    list.append(i)\n",
    "\n",
    "        if(not list):\n",
    "            return None\n",
    "        else:\n",
    "            return list\n",
    "    \n",
    "    if(genre==\"0\"):\n",
    "        for i in G:    \n",
    "            for j in G[i]:\n",
    "                if (j==sommet):\n",
    "                    list.append(i)\n",
    "        for i in G:\n",
    "            if(i==sommet):\n",
    "                for j in G[i]:\n",
    "                    list.append(j)\n",
    "        if(not list):\n",
    "            return None\n",
    "        else:\n",
    "            return list\n",
    "            \n",
    "#The set of successors of vertex x\n",
    "def Succ(G,sommet,genre):\n",
    "    list=[]\n",
    "    \n",
    "    if(genre==\"1\"):\n",
    "        for i in G:\n",
    "            if (i==sommet):\n",
    "                for j in G[i]:\n",
    "                    list.append(j)             \n",
    "        if(not list):\n",
    "            return None\n",
    "        else:\n",
    "            return list\n",
    "    \n",
    "    if(genre==\"0\"):\n",
    "        for i in G:\n",
    "            if(i==sommet):\n",
    "                for j in G[i]:\n",
    "                    list.append(j)\n",
    "        for i in G:    \n",
    "            for j in G[i]:\n",
    "                if (j==sommet):\n",
    "                    list.append(i)        \n",
    "        if(not list):\n",
    "            return None\n",
    "        else:\n",
    "            return list\n",
    "\n",
    "sommet=input(\"Give a vertex \")\n",
    "print(\"Pred(\",sommet,\") = \",Pred(G,sommet,genre))\n",
    "print(\"Succ(\",sommet,\") = \",Succ(G,sommet,genre))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Neighborhood of a summit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Give a vertex B\n",
      "['A', 'D', 'C']\n"
     ]
    }
   ],
   "source": [
    "def Voisinage(G,sommet):\n",
    "    voisinages=[]\n",
    "    pre=Pred(G,sommet,genre)\n",
    "    suc=Succ(G,sommet,genre)\n",
    "    for s in pre:\n",
    "        voisinages.append(s)\n",
    "    for s in suc:\n",
    "        if(s not in voisinages):\n",
    "            voisinages.append(s)\n",
    "    return(voisinages)\n",
    "\n",
    "sommet = input(\"Give a vertex \")\n",
    "print(Voisinage(G,sommet))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Degree of a vertex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Give a vertex B\n",
      "dG(B) =  3\n"
     ]
    }
   ],
   "source": [
    "#The outer half degree of the vertex x\n",
    "def DDE(G,sommet):\n",
    "    d = 0\n",
    "    for i in G:\n",
    "        if(i==sommet):\n",
    "            d = len(G[i])\n",
    "    return d\n",
    "\n",
    "#The interior half degree of the vertex x\n",
    "def DDI(G,sommet):\n",
    "    d = 0\n",
    "    for i in G:    \n",
    "        for j in G[i]:\n",
    "            if(j==sommet):\n",
    "                d+=1;\n",
    "    return d\n",
    "\n",
    "#The degree of the vertex x   \n",
    "def D(G,sommet):\n",
    "    d = 0\n",
    "    d = DDE(G,sommet)+DDI(G,sommet)\n",
    "    return d\n",
    "\n",
    "sommet = input(\"Give a vertex \")\n",
    "if(genre==1):\n",
    "    print(\"dG+(\"+sommet+\") = \",DDE(G,sommet))    \n",
    "    print(\"dG-(\"+sommet+\") = \",DDI(G,sommet))\n",
    "d=D(G,sommet)\n",
    "print(\"dG(\"+sommet+\") = \",d)\n",
    "if(d==0):\n",
    "    print(\"The vertex \\\"\"+sommet+\"\\\" is isolated\")\n",
    "if(d==1):\n",
    "    print(\"The vertex \\\"\"+sommet+\"\\\" is isolated\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Adjacency matrix\n",
    "* The adjacency matrix of a graph G is an n x n square matrix, each row and each column of which corresponds to a vertex."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adjacency matrix:  [[0, 1, 0, 0], [1, 0, 1, 1], [0, 1, 0, 1], [0, 1, 1, 0]]\n"
     ]
    }
   ],
   "source": [
    "def MAdjacence(G,genre):\n",
    "    sommets = Sommets(G)\n",
    "    Ma = []\n",
    "    if(genre==\"0\"):\n",
    "        for x in sommets:\n",
    "            L = []\n",
    "            for y in sommets:\n",
    "                if ((x in G.keys()) and (y in G[x])):\n",
    "                    L.append(1)\n",
    "                elif ((y in G.keys()) and (x in G[y])):\n",
    "                    L.append(1)\n",
    "                else:\n",
    "                    L.append(0)\n",
    "            Ma.append(L)\n",
    "        return Ma\n",
    "    elif genre==\"1\":\n",
    "        for x in sommets:\n",
    "            L = []\n",
    "            for y in sommets:\n",
    "                if ((x in G.keys()) and (y in G[x])):\n",
    "                    L.append(1)\n",
    "                else:\n",
    "                    L.append(0)\n",
    "            Ma.append(L)\n",
    "        return Ma\n",
    "\n",
    "Ma=MAdjacence(G,genre)\n",
    "print(\"Adjacency matrix: \",Ma)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Incidence matrix\n",
    "* The incidence matrix of a graph is an n x m matrix in which each row corresponds to a vertex and each column to an arc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Incidence matrix:  [[1, 0, 0, 0], [1, 1, 0, 1], [0, 1, 1, 0], [0, 0, 1, 1]]\n"
     ]
    }
   ],
   "source": [
    "def MIncidence(G,genre):\n",
    "    nb = 0\n",
    "    Mi = []\n",
    "    arcs = Arcs(G)\n",
    "    sommets = Sommets(G)\n",
    "    if(genre==\"0\"):\n",
    "        for s in sommets:\n",
    "            L = []\n",
    "            for a in arcs:\n",
    "                if (s in a):\n",
    "                    L.append(1)\n",
    "                else:\n",
    "                    L.append(0)\n",
    "            Mi.append(L)\n",
    "        return Mi\n",
    "    elif genre==\"1\":\n",
    "        for s in sommets:\n",
    "            L = []\n",
    "            for a in arcs:\n",
    "                if (s in a[0]):\n",
    "                    L.append(1)\n",
    "                else:\n",
    "                    L.append(0)\n",
    "            Mi.append(L)\n",
    "        return Mi\n",
    "\n",
    "MI=MIncidence(G,genre)\n",
    "print(\"Incidence matrix: \",MI)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Simple graph\n",
    "* A graph is simple if it has no loops and no parallel arcs (resp. Edges)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The graph G is simple\n"
     ]
    }
   ],
   "source": [
    "def Simple(G):\n",
    "    b = True\n",
    "    for i in G:\n",
    "        for j in G[i]:\n",
    "            if (j in G):\n",
    "                if (( i in G[j]) or (i==j )):\n",
    "                    b = False\n",
    "    if not(b):\n",
    "        print(\"The graph G is not simple\")\n",
    "    else:\n",
    "        print(\"The graph G is simple\")\n",
    "        \n",
    "Simple(G)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Complete graph\n",
    "* A complete graph is a graph where each vertex is connected to all the others"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The graph G is not complete\n"
     ]
    }
   ],
   "source": [
    "def Complet(G):\n",
    "    b = True\n",
    "    sommets = Sommets(G)\n",
    "    Ma = MAdjacence(G,genre)\n",
    "    for i in range(len(sommets)):\n",
    "        nb = 0\n",
    "        for j in range(len(sommets)):\n",
    "            if(( Ma[i][j]==1) and (i!=j)) :\n",
    "                nb+=1\n",
    "        if(nb < (len(sommets)-1)):\n",
    "            b = False\n",
    "    if(not(b)):\n",
    "        print(\"The graph G is not complete\")\n",
    "    else:\n",
    "        print(\"The graph G is complete\")\n",
    "\n",
    "Complet(G)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Add or remove a vertex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def AjouteS(G,sommet):\n",
    "    if sommet not in G.keys():\n",
    "        G[sommet] = []\n",
    "    else:\n",
    "        print(\"Summit already exists\")\n",
    "\n",
    "def SupprimeS(G,sommet):\n",
    "    if sommet in G.keys():\n",
    "        del(G[sommet])\n",
    "    else:\n",
    "        print(\"This summit does not exist\")\n",
    "\n",
    "AjouteS(G,\"N\")\n",
    "TraceG(G,genre)\n",
    "SupprimeS(G,\"N\")\n",
    "TraceG(G,genre)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Add or remove an arc / edge\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The arc/edge does not exist\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The arc/edge does not exist\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def AjouteA(G,eI,eF):\n",
    "    sommets = Sommets(G)\n",
    "    if((eI in sommets) and (eF in sommets)):\n",
    "        if(eI in G.keys()):\n",
    "            G[eI].append(eF)\n",
    "        else:\n",
    "            G[eI] = []\n",
    "            G[eI].append(eF)\n",
    "    else:\n",
    "        print(\"The arc/edge does not exist\")\n",
    "\n",
    "def SupprimeA(G,eI,eF):\n",
    "    sommets = Sommets(G)\n",
    "    if((eI in sommets) and (eF in sommets)):\n",
    "        G[eI].remove(eF)\n",
    "    else:\n",
    "        print(\"The arc/edge does not exist\")\n",
    "\n",
    "AjouteA(G,\"a\",\"c\")\n",
    "TraceG(G,genre)\n",
    "SupprimeA(G,\"a\",\"c\")\n",
    "TraceG(G,genre)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Related graph\n",
    "* From a graph G of n vertices and of adjacency matrix X, is connected if and only if the matrix Y does not contain a zero non-diagonal term.\n",
    "Y = X+X^2+X^3+…+X^(n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Le graphe G est connexe\n"
     ]
    }
   ],
   "source": [
    "def Multi(m1, m2):\n",
    "    Mm = []\n",
    "    for i in range(len(m1)):\n",
    "        ligne = []\n",
    "        for j in range(len(m1)):\n",
    "            element = 0\n",
    "            for k in range(len(m1)):\n",
    "                if ( (element==1) or (m1[i][k] * m2[k][j]==1) ):\n",
    "                    element = 1\n",
    "                else:\n",
    "                    element = 0\n",
    "            ligne.append(element)\n",
    "        Mm.append(ligne) \n",
    "    return Mm\n",
    "\n",
    "def Som(m1, m2):\n",
    "    Sm = []\n",
    "    for i in range(len(m1)):\n",
    "        ligne = []\n",
    "        for j in range(len(m1)):\n",
    "            if((m1[i][j]==1) or (m2[i][j]==1) ):\n",
    "                element = 1\n",
    "            else:\n",
    "                element = 0\n",
    "            ligne.append(element)\n",
    "        Sm.append(ligne)\n",
    "    return Sm\n",
    "\n",
    "def Connexe(Ma):\n",
    "    n = len(Ma)\n",
    "    Y = Ma\n",
    "    m = Ma\n",
    "    for x in range(n-2):\n",
    "        m = Multi(m,Ma)\n",
    "        Y = Som(Y,m)\n",
    "    return Y\n",
    "\n",
    "Ma = MAdjacence(G,genre)\n",
    "Y = Connexe(Ma)\n",
    "connexe = True\n",
    "for i in range(len(Y)):\n",
    "    for j in range(len(Y)):\n",
    "        if((i!=j) and (Y[i][j]==0)):\n",
    "            connexe = False\n",
    "            break\n",
    "if connexe:\n",
    "    print(\"Le graphe G est connexe\")\n",
    "else:\n",
    "    print(\"The graph G is not connected\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Euler graph\n",
    "* The graph G is an Eulerian graph if and only if it admits an Eulerian cycle.\n",
    "* A cycle is a closed chain (does not have the same edge twice).\n",
    "* A chain is said to be Eulerian if it is simple and passes through all the edges of the graph.\n",
    "* A connected graph G admits an Eulerian cycle if and only if all its vertices are of even degree."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The graph G is not Eulerian\n"
     ]
    }
   ],
   "source": [
    "def Euler(G):\n",
    "    euler = True\n",
    "    Ma = MAdjacence(G,genre)\n",
    "    Y = Connexe(Ma)\n",
    "    connexe = True\n",
    "    for i in range(len(Y)):\n",
    "        for j in range(len(Y)):\n",
    "            if((i!=j) and (Y[i][j]==0)):\n",
    "                connexe = False\n",
    "                break \n",
    "    sommets=Sommets(G)\n",
    "    if(connexe):\n",
    "        for s in sommets:\n",
    "            if(D(G,s)%2!=0):\n",
    "                euler = False\n",
    "                break\n",
    "        if(euler):\n",
    "            print(\"The graph G is Eulerian\")\n",
    "        else:\n",
    "            print(\"The graph G is not Eulerian\")\n",
    "    else:\n",
    "        print(\"The graph G is not Eulerian\")\n",
    "\n",
    "Euler(G)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Strongly related\n",
    "* A directed graph is said to be strongly connected if its vertices are all accessible to each other, i.e., for any pair of vertices u and v there exists a path from u to v and also a path from v to u."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The graph G is strongly connected\n"
     ]
    }
   ],
   "source": [
    "def FortementConexee(G):\n",
    "    sommets = Sommets(G)\n",
    "    plus,moins = [],[]\n",
    "    done = False\n",
    "    nbFC = 0\n",
    "    while(done==False):\n",
    "        plus.append(sommets[0])\n",
    "        moins.append(sommets[0])\n",
    "        for s in plus:\n",
    "            succs = Succ(G,s,genre) \n",
    "            for ss in succs:\n",
    "                if(ss not in plus):\n",
    "                    plus.append(ss)\n",
    "        for s in moins:\n",
    "            preds = Pred(G,s,genre) \n",
    "            for ps in preds:\n",
    "                if(ps not in moins):\n",
    "                    moins.append(ps)\n",
    "        plus,moins = set(plus),set(moins)\n",
    "        fc = plus.intersection(moins)\n",
    "        nbFC+=1       \n",
    "        if(len(fc)!=len(sommets)):\n",
    "            sommets = list(set(sommets)-fc)\n",
    "            plus,moins=[],[]\n",
    "        else:\n",
    "            done = True\n",
    "    if(nbFC==1):\n",
    "        print(\"The graph G is strongly connected\")\n",
    "    else:\n",
    "        print(\"The graph G is not strongly connected\")\n",
    "\n",
    "FortementConexee(G)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Existence of a cycle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The graph G contains a cycle\n"
     ]
    }
   ],
   "source": [
    "def Cycle(G):\n",
    "    sommets = Sommets(G)\n",
    "    path = []\n",
    "    for sommet in sommets:\n",
    "        for vs in Voisinage(G,sommet):\n",
    "            if(vs not in path[-1:]):\n",
    "                path.append(vs)\n",
    "                if(vs in path):\n",
    "                    return True\n",
    "        path = []\n",
    "    return False\n",
    "            \n",
    "cycle = Cycle(G)\n",
    "if(cycle):\n",
    "    print(\"The graph G contains a cycle\")\n",
    "else:\n",
    "    print(\"The graph G contains no cycle\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Welsh and Powell algorithm\n",
    "* Graph coloring consists of assigning a color to each of its vertices so that two vertices connected by an edge are of different color."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def WelshPowell(G):\n",
    "    #Color chart\n",
    "    couleurs = [\"blue\",\"green\",\"red\",\"brown\",\"gray\",\"pink\"]\n",
    "    Ma = MAdjacence(G,genre)\n",
    "    sommets = Sommets(G)\n",
    "    degres,result = [],[]\n",
    "    nb = 0\n",
    "    for sommet in sommets:\n",
    "        degres.append(len(Voisinage(G,sommet)))\n",
    "        result.append(0)\n",
    "    degres.sort()\n",
    "    for i in range(len(degres)):\n",
    "        if(result[i]==0):\n",
    "            nb+=1\n",
    "            result[i] = couleurs[nb]\n",
    "            for j in range(len(degres)): \n",
    "                if(Ma[i][j]==0 and result[j]==0):\n",
    "                    for k in range(len(degres)):\n",
    "                        passe = 0\n",
    "                        if(Ma[j][k]==1 and result[k]==result[i]):\n",
    "                            passe = 1\n",
    "                            break\n",
    "                    if(passe==0):\n",
    "                        result[j] = result[i]\n",
    "    d,i = {},0\n",
    "    for sommet in sommets:\n",
    "        d[sommet] = result[i]\n",
    "        i+=1\n",
    "    #Graphical representation of our graph after applying the algorithm\n",
    "    graph=pydot.Dot(graph_type=\"graph\")\n",
    "    for i in sommets:    \n",
    "        node = pydot.Node(i,style=\"filled\",fillcolor=d[i])\n",
    "        graph.add_node(node)\n",
    "    for i in G: \n",
    "        for j in G[i]:\n",
    "            arc = pydot.Edge(i,j)\n",
    "            graph.add_edge(arc)\n",
    "    img = Image(graph.create_png())\n",
    "    display(img)\n",
    "\n",
    "WelshPowell(G)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Trees"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Give the weight of the bow AB 4\n",
      "Give the weight of the bow BC 1\n",
      "Give the weight of the bow CD 5\n",
      "Give the weight of the bow DB 2\n"
     ]
    }
   ],
   "source": [
    "def Ajpoids(G):\n",
    "    sommets = Sommets(G)\n",
    "    M = MAdjacence(G,genre)\n",
    "    ar = Arcs(G)\n",
    "    arcs = {}\n",
    "    for i in range(len(ar)):\n",
    "        arcs[ar[i]] = int(input(\"Give the weight of the bow \"+ar[i]+\" \"))\n",
    "    return(arcs)\n",
    "\n",
    "arcs=Ajpoids(G)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Tree trace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def TraceA(G):\n",
    "    graph = pydot.Dot(graph_type=\"graph\")\n",
    "    for i in G:    \n",
    "        node = pydot.Node(i)\n",
    "        graph.add_node(node)\n",
    "        for j in G[i]:\n",
    "            arc = i+j\n",
    "            arc = pydot.Edge(i,j,label=arcs[arc])\n",
    "            graph.add_edge(arc)\n",
    "    img = Image(graph.create_png())\n",
    "    display(img)\n",
    "\n",
    "TraceA(G)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Kruskal's algorithm\n",
    "* The algorithm builds a minimum spanning tree by selecting edges by increasing weight.\n",
    "* A spanning tree is a connected subgraph without a cycle that contains all the vertices of the graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The tree size covering minimum weight is:  14\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def kruskal(G,sommets):\n",
    "    T = [[0 for i in range(len(G))] for j in range(len(G))]\n",
    "    n = 0\n",
    "    d = {}\n",
    "    path = []\n",
    "    bol = False\n",
    "    taille = 0\n",
    "    for i in range(len(G)):\n",
    "        for j in range(len(G)):\n",
    "            if(G[i][j]!=0):\n",
    "                arc = (i,j)\n",
    "                #Create a dictionary that contains each edge is its weight\n",
    "                d[arc] = G[i][j]\n",
    "    #Sort edges by weight\n",
    "    A = sorted(d.items(), key=lambda kv: kv[1])\n",
    "\n",
    "    for i in A:\n",
    "        #Calculate Y = X+X^2+X^3+…+X^(n-1)\n",
    "        Y = Connexe(T)\n",
    "        source,cible = i[0][0],i[0][1]\n",
    "        #If there is no path between source and target add the edge to path\n",
    "        if(Y[source][cible]!=1) and (Y[cible][source]!=1):\n",
    "            T[cible][source],T[source][cible] = 1,1\n",
    "            path.append(i)\n",
    "            n+=1\n",
    "        #The algorithm stops when the number of edges of T is equal to N-1.\n",
    "        if(n==len(G)-1):\n",
    "            break\n",
    "    #Graphical representation of our graph after applying the algorithm\n",
    "    graph = pydot.Dot(graph_type=\"graph\")\n",
    "    for i in range(len(sommets)):\n",
    "        node = pydot.Node(sommets[i],style=\"filled\")\n",
    "        graph.add_node(node)\n",
    "        \n",
    "    for i in range(len(G)):\n",
    "        for j in range(len(G)):    \n",
    "            if(G[i][j]!=0):\n",
    "                for p in path:\n",
    "                    if((p[0][0]==j and p[0][1]==i) or (p[0][0]==i and p[0][1]==j)):\n",
    "                        bol = True\n",
    "                        break\n",
    "                if(not(bol)):\n",
    "                    arc = pydot.Edge(sommets[i],sommets[j],label=G[i][j])\n",
    "                    graph.add_edge(arc)\n",
    "            bol = False\n",
    "    for p in path:\n",
    "        arc = pydot.Edge(sommets[p[0][0]],sommets[p[0][1]],label=p[1],color=\"red\")\n",
    "        graph.add_edge(arc)\n",
    "        taille+=p[1]\n",
    "    print(\"The tree size covering minimum weight is: \",taille)\n",
    "    img = Image(graph.create_png())\n",
    "    display(img)\n",
    "\n",
    "sommets={0:'v1',1:'v2',2:'v3',3:'v4',4:'v5',5:'v6'}\n",
    "G=[[0, 2, 1, 0, 0, 0],\n",
    "   [0, 0, 1, 7, 0, 0],\n",
    "   [0, 0, 0, 5, 9, 0],\n",
    "   [0, 0, 0, 0, 5, 3],\n",
    "   [0, 0, 0, 0, 0, 4],\n",
    "   [0, 0, 0, 0, 0, 0]]\n",
    "kruskal(G,sommets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Prim's algorithm\n",
    "* The algorithm consists in making a tree grow from a vertex. We start with a single vertex then at each step, we add an edge of minimum weight having exactly one end in the tree under construction. Indeed, if its two ends already belonged to the tree, the addition of this edge would create a second path between the two vertices in the tree under construction and the result would contain a cycle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The size of the tree covering minimum weight is:  13\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def Prim(G,sommets):\n",
    "    Path,plusProche,distanceMin = [],[],[]\n",
    "    n = len(G)\n",
    "    taille = 0\n",
    "    \n",
    "    #Initialize Nearest and Min distance with zeros\n",
    "    for i in range(0,n):\n",
    "        plusProche.append(0)\n",
    "        distanceMin.append(0)\n",
    "    \n",
    "    #Remotely assign Mine the weights of the source neighborhoods\n",
    "    for i in range(1,n):\n",
    "        distanceMin[i] = G[i][0]\n",
    "    \n",
    "    for i in range(0,n-1):\n",
    "        Min = 0\n",
    "        #Edge condition if all vertices are processed\n",
    "        if(len(Path)+1==len(sommets)):\n",
    "            break\n",
    "        \n",
    "        for j in range(1,n):\n",
    "            #Assign index the top index that is close to current top\n",
    "            if(( 0 < distanceMin[j] < Min) or (not Min and 0 <= distanceMin[j])):\n",
    "                Min = distanceMin[j]\n",
    "                indice = j\n",
    "        #Assign the index of the closest to the current vertex to the \"Path\" dictionary\n",
    "        Path.append((indice, plusProche[indice]))\n",
    "        #Assign -1 to all vertices already processed\n",
    "        distanceMin[indice] = -1\n",
    "        distanceMin[plusProche[indice]] = -1\n",
    "        \n",
    "        for j in range(1,n):\n",
    "            #Assign remotely Mine the weights of the neighborhoods of current vertex \"index\"\n",
    "            if (( 0 < G[indice][j] < distanceMin[j]) or (not distanceMin[j])):\n",
    "                distanceMin[j] = G[indice][j]\n",
    "                distanceMin[indice] = G[indice][j]\n",
    "                plusProche[j] = indice\n",
    "                plusProche[indice] = j\n",
    "\n",
    "    #Graphical representation of our graph after applying the algorithm\n",
    "    graph=pydot.Dot(graph_type=\"graph\")\n",
    "    \n",
    "    for i in range(len(sommets)):\n",
    "        node=pydot.Node(sommets[i],style=\"filled\")\n",
    "        graph.add_node(node)\n",
    "\n",
    "    for i in range(len(G)):\n",
    "        for j in range(len(G)):\n",
    "            if(i==j):\n",
    "                break\n",
    "            if(G[i][j]!=0):\n",
    "                for p in Path:\n",
    "                    if(p[0]==i and p[1]==j):\n",
    "                        bol=True\n",
    "                    elif(p[0]==j and p[1]==i):\n",
    "                        bol=True\n",
    "                if(bol==True):\n",
    "                    arc=pydot.Edge(sommets[i],sommets[j],label=G[i][j],color=\"red\")\n",
    "                    taille+=G[i][j]\n",
    "                    bol=False\n",
    "                else:\n",
    "                    arc=pydot.Edge(sommets[i],sommets[j],label=G[i][j])\n",
    "                graph.add_edge(arc)\n",
    "    print(\"The size of the tree covering minimum weight is: \",taille)\n",
    "    img=Image(graph.create_png())\n",
    "    display(img)\n",
    "\n",
    "sommets={0:'A',1:'B',2:'C',3:'D',4:'E',5:'F'} \n",
    "G = [[0, 1, 7, 3, 0, 0],\n",
    "     [1, 0, 0, 2, 4, 0],\n",
    "     [7, 0, 0, 3, 0, 5],\n",
    "     [3, 2, 3, 0, 6,10],\n",
    "     [0, 4, 0, 6, 0, 3],\n",
    "     [0, 0, 5,10, 3, 0]]\n",
    " \n",
    "Prim(G,sommets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Shortest paths in a graph\n",
    "## Dijkstra's algorithm\n",
    "* At the start, we consider that the distances from each vertex to the starting vertex are infinite, except for the starting vertex for which the distance is zero. The starting subgraph is the empty set.\n",
    "* During each iteration, we choose outside the subgraph a vertex of minimum distance and we add it to the subgraph. Then, we update the distances of the neighboring vertices of the added one. The update works as follows: the new distance from the neighboring vertex is the minimum between the existing distance and that obtained by adding the weight of the arc between neighboring vertex and vertex added to the distance from the added vertex.\n",
    "* Continue in this way until the summits are exhausted (or until the arrival summit is selected)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def Dijkstra(G):\n",
    "    sommets = {0:'A',1:'B',2:'C',3:'D',4:'E',5:'F',6:'G'}\n",
    "    V = [0,1,2,3,4,5,6]\n",
    "    T,bol = set(),False\n",
    "    tab,trace,d,path,voisinages = [],[],{},{},{}\n",
    "    #Neighborhoods contains each vertex with these successors\n",
    "    for i in range(len(G)):\n",
    "        for j in range(len(G[i])):\n",
    "            if(G[i][j]!=0):\n",
    "                tab.append(V[j])\n",
    "        voisinages[V[i]] = tab\n",
    "        tab = [] \n",
    "    V = set(V)\n",
    "    #Initialize d(i) = 999 for all vertices i\n",
    "    for v in range(len(V)):\n",
    "        d[v] = 999\n",
    "    #Initialize d(s) = 0\n",
    "    d[0] = 0\n",
    "    #Edge condition if all vertices are processed\n",
    "    while(T!=V):\n",
    "        #Sort array d by weight\n",
    "        v = sorted(d.items(), key=lambda kv: kv[1])\n",
    "        for i in v:\n",
    "            if(i[0] not in T) :\n",
    "                T.add(i[0])\n",
    "                break\n",
    "        for voisinage in voisinages[i[0]]:\n",
    "            d[voisinage] = min(d[voisinage],d[i[0]]+G[i[0]][voisinage])\n",
    "            path[voisinage] = i[0]\n",
    "    #Graphical representation of our graph after applying the algorithm\n",
    "    graph = pydot.Dot(graph_type=\"digraph\")\n",
    "    path[0] = 0\n",
    "    for i in range(len(V)):\n",
    "        node = pydot.Node(str(sommets[i])+\" (\"+str(d[i])+\",\"+str(sommets[path[i]])+\")\",style=\"filled\")\n",
    "        graph.add_node(node)\n",
    "        \n",
    "    for i in range(len(V)):\n",
    "        for j in range(len(V)):    \n",
    "            if(G[i][j]!=0):\n",
    "                arc = pydot.Edge(str(sommets[i])+\" (\"+str(d[i])+\",\"+str(sommets[path[i]])+\")\",str(sommets[j])+\" (\"+str(d[j])+\",\"+str(sommets[path[j]])+\")\",label=G[i][j])\n",
    "                graph.add_edge(arc)\n",
    "    img = Image(graph.create_png())\n",
    "    display(img)\n",
    "\n",
    "G= [[0, 4, 1, 0, 0, 0, 0],\n",
    "    [0, 0, 0, 1, 2, 0, 0],\n",
    "    [0, 2, 0, 1, 0, 5, 0],\n",
    "    [0, 0, 0, 0, 2, 0, 3],\n",
    "    [0, 0, 0, 0, 0, 0, 4],\n",
    "    [0, 0, 0, 0, 0, 0, 1],\n",
    "    [0, 0, 0, 0, 0, 0, 0]]\n",
    "\n",
    "Dijkstra(G)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Bellman-Ford algorithm\n",
    "* The contribution of this algorithm to that of Dijkstra is the possibility of having negative weights between vertices.\n",
    "* Like Dijkstra's algorithm, the first step is to initialize the costs to infinity and set the starting vertex to 0. Subsequently, the Bellman-Ford algorithm updates the costs for each vertex (therefore checks for each edge) and this, as many times as the number of vertices of the graph minus one. This has the effect of stabilizing the cost of all paths unless there is a negative weight cycle.\n",
    "* This algorithm is an improvement of Dijkstra since it accepts negative weights. However, it requires a longer execution time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def BellmanFord(G,sommets,s):\n",
    "    Y = {}\n",
    "    arcs = []\n",
    "    n = len(G)\n",
    "    #Initialize y(i) = 999 for all vertices i\n",
    "    for i in range(n):\n",
    "        Y[i] = [999,0]\n",
    "    #Initialiser y(s) = 0\n",
    "    Y[s][0] = 0\n",
    "\n",
    "    #Fill arcs with all graph arcs\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            if(G[i][j]!=0):\n",
    "                arcs.append((i,j))\n",
    "    #Edge condition if (n-1) iterations or there is more Relaxation\n",
    "    for k in range(n-1):\n",
    "        for arc in arcs:\n",
    "            #Relacher (a,b, c(a,b))\n",
    "            a,b,c = Y[arc[1]][0],Y[arc[0]][0],G[arc[0]][arc[1]]\n",
    "            if(a>b+c):\n",
    "                Y[arc[1]][0]=b+c\n",
    "                Y[arc[1]][1]=arc[0]\n",
    "                \n",
    "    #Graphical representation of our graph after applying the algorithm \n",
    "    graph=pydot.Dot(graph_type=\"digraph\")\n",
    "    for i in range(n):\n",
    "        node = pydot.Node(str(sommets[i])+\", \"+str(Y[i][0]),style=\"filled\")\n",
    "        graph.add_node(node)\n",
    "        \n",
    "    for i in range(n):\n",
    "        for j in range(n):    \n",
    "            if(G[i][j]!=0):\n",
    "                arc = pydot.Edge(str(sommets[i])+\", \"+str(Y[i][0]),str(sommets[j])+\", \"+str(Y[j][0]),label=G[i][j])\n",
    "                graph.add_edge(arc)\n",
    "    img = Image(graph.create_png())\n",
    "    display(img)\n",
    "    \n",
    "sommets = {0:'s',1:'a',2:'b',3:'c',4:'d'}\n",
    "G= [[0, 3, 0, 5, 0],\n",
    "   [0, 0, 5, 1, 0],\n",
    "   [0, 0, 0, 0,-1],\n",
    "   [0,-1, 5, 0, 5],\n",
    "   [-3, 0, 3, 0, 0]]   \n",
    "source = 0\n",
    "BellmanFord(G,sommets,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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}