Recursive, dynamic programming and Graph paradigms

.gitignore

@@ -0,0 +1 @@
+algorithms/*checkpoint*

algorithms/DynamicProgrammingParadigm.ipynb

@@ -0,0 +1,68 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "380\n"
+     ]
+    }
+   ],
+   "source": [
+    "'''Weighted interval schedule\n",
+    "Input: Number of Jobs n = 4\n",
+    "       Job Details {Start Time, Finish Time, Profit}\n",
+    "       Job 1:  {1, 2, 50} \n",
+    "       Job 2:  {3, 5, 20}\n",
+    "       Job 3:  {6, 19, 100}\n",
+    "       Job 4:  {2, 100, 200}\n",
+    "       This gives a the max sum of weights of the continuous jobs \n",
+    "       '''\n",
+    "\n",
+    "jobs = [{1, 2, 50}, {3, 5, 230}, {6, 19, 100}, {2, 100, 200}]\n",
+    "v = [50, 230, 100, 200]\n",
+    "N = len(v)\n",
+    "p = [0] * N\n",
+    "p[0] = 0\n",
+    "p[1] = 0\n",
+    "p[2] = 1\n",
+    "p[3] = 0\n",
+    "M = [0] * N\n",
+    "\n",
+    "def WeightedInterval():\n",
+    "    global p\n",
+    "    global M\n",
+    "    for i in range(N):\n",
+    "        M[i] = max(v[i] + M[p[i]], M[i - 1])\n",
+    "WeightedInterval()\n",
+    "print(M[3])"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "cnn",
+   "language": "python",
+   "name": "cnn"
+  },
+  "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.6.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

algorithms/GraphsParadigms.ipynb

@@ -0,0 +1,316 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Graph:\n",
+    "    adj: dict = None\n",
+    "    V: int = None\n",
+    "    def __init__(self, V):\n",
+    "        self.adj = {}\n",
+    "        self.V = V\n",
+    "        for i in range(V):\n",
+    "            self.adj[i] = []\n",
+    "        \n",
+    "    def addEdge(self, v, w):\n",
+    "        self.adj[v].append(w)\n",
+    "        self.adj[w].append(v)\n",
+    "        \n",
+    "    def __str__(self):\n",
+    "        retString = \"\"\n",
+    "        for k, v in self.adj.items():\n",
+    "            if [] != v:\n",
+    "                retString += ('{}: {}\\n'.format(k, str(v)))\n",
+    "        return retString\n",
+    "    def __iter__(self):\n",
+    "        for k, v in self.adj.items():\n",
+    "            if v != []:\n",
+    "                yield k, v\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class DirectedGraph:\n",
+    "    adj = None\n",
+    "    V = None\n",
+    "    def __init__(self, V):\n",
+    "        self.adj = {}\n",
+    "        self.V = V\n",
+    "        for i in range(V):\n",
+    "            self.adj[i] = []\n",
+    "    def addEdge(self, v, w):\n",
+    "        self.adj[v].append(w)\n",
+    "    def V(self):\n",
+    "        return self.V\n",
+    "        \n",
+    "def reverseGraph(g:DirectedGraph) -> DirectedGraph:\n",
+    "    reverseGraph = DirectedGraph(g.V)\n",
+    "    for v, w in g.adj.items():\n",
+    "        for _v in w:\n",
+    "            reverseGraph.addEdge(_v, v)\n",
+    "    return reverseGraph"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class DfsPaths():\n",
+    "    marked: list = None\n",
+    "    source = None\n",
+    "    edgeTo: list = None\n",
+    "    \n",
+    "    def __init__(self, G: Graph, s: int):\n",
+    "        self.marked = [False] * G.V\n",
+    "        self.edgeTo = [0] * G.V\n",
+    "        self.source = s\n",
+    "        self.dfs(G, s)\n",
+    "        \n",
+    "    def hasPathTo(self, v: int):\n",
+    "        return self.marked[v] \n",
+    "    \n",
+    "    def pathTo(self, v: int):\n",
+    "        node = v\n",
+    "        path = []\n",
+    "        if self.hasPathTo(v):\n",
+    "            while node != self.source:\n",
+    "                path.append(node)\n",
+    "                node = self.edgeTo[node]    \n",
+    "            path.append(self.source)\n",
+    "            path.reverse()\n",
+    "        return path\n",
+    "            \n",
+    "    def dfs(self, G, s):\n",
+    "        self.marked[s] = True\n",
+    "        for v in G.adj[s]:\n",
+    "            if self.marked[v] == False:\n",
+    "                self.dfs(G, v)\n",
+    "                self.edgeTo[v] = s\n",
+    "            "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from collections import deque\n",
+    "class BfsPaths:\n",
+    "    marked: list = None\n",
+    "    edgeTo: list = None\n",
+    "    bfsQueue: deque = None\n",
+    "    distTo: list = None\n",
+    "    def __init__(self, G: Graph, s):\n",
+    "        self.marked = [False] * G.V\n",
+    "        self.edgeTo = [0] * G.V\n",
+    "        self.bfsQueue = deque([])\n",
+    "        self.distTo = [0] * G.V\n",
+    "        self._bfs(G, s)\n",
+    "        \n",
+    "    def _bfs(self, G: Graph, s):\n",
+    "#         count = 0\n",
+    "        if self.marked[s] == False:\n",
+    "            self.bfsQueue.append(s)\n",
+    "            self.marked[s] = True\n",
+    "            self.distTo[s] = 0\n",
+    "        \n",
+    "        while len(self.bfsQueue) != 0:\n",
+    "            node = self.bfsQueue.popleft()\n",
+    "            for v in G.adj[node]:\n",
+    "                if self.marked[v] == False:\n",
+    "                    self.marked[v] = True\n",
+    "                    self.bfsQueue.append(v)\n",
+    "                    self.edgeTo[v] = s\n",
+    "                    self.distTo[v] = self.distTo[node] + 1\n",
+    "    \n",
+    "    def Dist(self, v):\n",
+    "        return self.distTo[v]\n",
+    "            \n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class ConnectedComponents:\n",
+    "    count = None\n",
+    "    G: Graph = None\n",
+    "    id = None\n",
+    "    marked = None\n",
+    "    def __init__(self, G):\n",
+    "        self.count = 0\n",
+    "        self.G = G\n",
+    "        self.id = [0] * G.V\n",
+    "        self.marked = [False] * G.V\n",
+    "        self.CC()\n",
+    "    def CC(self):\n",
+    "        for v, _ in self.G.adj.items():\n",
+    "#             print(v)\n",
+    "            if self.marked[v] == False and self.G.adj[v] != []:\n",
+    "                self.count += 1\n",
+    "                self.dfs(self.G, v)\n",
+    "                \n",
+    "    def dfs(self, G, s):\n",
+    "        for v in G.adj[s]:\n",
+    "            if self.marked[v] == False:\n",
+    "                self.marked[v] = True\n",
+    "                self.id[v] = self.count\n",
+    "                self.dfs(G, v)\n",
+    "    def isConnected(self, v, w):\n",
+    "        return self.id[v] == self.id[w]\n",
+    "    \n",
+    "    def count(self):\n",
+    "        return self.count\n",
+    "                \n",
+    "            "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def createGraph(g):\n",
+    "    g.addEdge(1,7)\n",
+    "    g.addEdge(1,4)\n",
+    "    g.addEdge(1,2)\n",
+    "    g.addEdge(2,4)\n",
+    "    g.addEdge(2,3)\n",
+    "    g.addEdge(3,5)\n",
+    "    g.addEdge(3,6)\n",
+    "#     g.addEdge(8,9)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 359,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n",
+      "[2, 1, 7]\n",
+      "1\n",
+      "True\n",
+      "[2, 3, 6]\n"
+     ]
+    }
+   ],
+   "source": [
+    "g = Graph(10)\n",
+    "createGraph(g)\n",
+    "paths = DfsPaths(g, 2)\n",
+    "print(paths.hasPathTo(7))\n",
+    "print(paths.pathTo(7))\n",
+    "bfs = BfsPaths(g, 2)\n",
+    "print(bfs.Dist(1))\n",
+    "\n",
+    "##### Directed Graphs client ######\n",
+    "dg = DirectedGraph(10)\n",
+    "createGraph(dg)\n",
+    "dgPaths = DfsPaths(dg, 2)\n",
+    "print(dgPaths.hasPathTo(5))\n",
+    "print(dgPaths.pathTo(6))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 404,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2\n"
+     ]
+    }
+   ],
+   "source": [
+    "### Connected components\n",
+    "g = Graph(10)\n",
+    "createGraph(g)\n",
+    "cc = ConnectedComponents(g)\n",
+    "print(cc.count)\n",
+    "assert cc.isConnected(8,1) == False\n",
+    "assert cc.isConnected(8,9) == True\n",
+    "assert cc.isConnected(1,4) == True\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1, 2, 3, 6, 5, 4, 7]\n"
+     ]
+    }
+   ],
+   "source": [
+    "### Topological sort\n",
+    "g = DirectedGraph(10)\n",
+    "createGraph(g)\n",
+    "\n",
+    "def dfsTop(g, s):\n",
+    "    for v in g.adj[s]:\n",
+    "        if marked[v] == False:\n",
+    "            dfsTop(g, v)\n",
+    "            marked[v] = True\n",
+    "    topology.append(s)\n",
+    "\n",
+    "def topoSort(g)\n",
+    "    marked = [False] * g.V\n",
+    "    topology = []\n",
+    "    for v, _ in g.adj.items():\n",
+    "        if g.adj[v] != [] and marked[v] == False:\n",
+    "    #         marked[v] = True\n",
+    "            dfsTop(g, v)\n",
+    "\n",
+    "    topology.reverse()\n",
+    "print(topology)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "cnn",
+   "language": "python",
+   "name": "cnn"
+  },
+  "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.6.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}