Max_Flow_and_Max_BP_Matching_in_Graphs.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bipartiteness, Edmonds-Karp / Ford-Fulkerson Algorithm for Max Flow,  Max Bipartite Matching\n",
    "\n",
    "#### 1- Python program to find out whether a given graph is bipartite or not \n",
    "Algorithm: With BFS, start coloring each node either for 0 or 1 in this order: Assign color 0 to the source vertex. Color all the neighbors with the color 1. Color all neighbor’s neighbor with 0 color.\n",
    "\n",
    "If all vertices connected to each other have different colors, then the graph is bipartite. \n",
    "\n",
    "Assumptions: Graph is connected and if it has no edges, it is still a bipartite graph.\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 0 1 0 1]\n",
      " [1 0 1 0 1 0]\n",
      " [0 1 0 1 0 1]\n",
      " [1 0 1 0 1 0]\n",
      " [0 1 0 1 0 1]\n",
      " [1 0 1 0 1 0]]\n"
     ]
    }
   ],
   "source": [
    "# create a densely connected test graph where there are 2 sets of nodes, colored either with 0 or 1. \n",
    "# Make sure no nodes are connected to its own kind. The 1's in the graph means there is an edge between these nodes.\n",
    "\n",
    "# Edges between vertices:\n",
    "\n",
    "# 0 -- 1   0 -- 3   0 -- 5\n",
    "   \n",
    "# 2 -- 3   2 -- 1   2 -- 5\n",
    "  \n",
    "# 4 -- 5   4 -- 1   4 -- 3\n",
    "\n",
    "# with the reverse edges, makes total 18 directed connections between 6 nodes (noted with 1) in the below matrix\n",
    "\n",
    "import numpy as np\n",
    "m = 6\n",
    "raw_matrix = np.zeros([m, m], dtype = int)\n",
    "for i in range(len(raw_matrix)): # for each row\n",
    "    for j in range(len(raw_matrix[0])): # for each column\n",
    "        if i % 2 == 0 and j % 2 == 1: # if the i index is even and j is odd\n",
    "            raw_matrix[i][j] = 1\n",
    "        if i % 2 == 1 and j % 2 == 0: # if the in index is odd and j is even\n",
    "            raw_matrix[i][j] = 1\n",
    "\n",
    "print(raw_matrix)\n",
    "\n",
    "test_matrix = raw_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 0, 1, 0, 1, 0]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# use the test matrix above to test the function below\n",
    "            \n",
    "def check_if_bipartite(matrix): \n",
    "   \n",
    "    # Create a color list for each vertex\n",
    "    color_list = [False] * len(matrix) # assign -1 to each vertex, the vertices later will take 0 or 1\n",
    "\n",
    "    # Assign first color to source vertex, pick the first vertex as source vertex for convenience\n",
    "    color_list[0] = 1\n",
    "\n",
    "    # Create a queue (FIFO) of vertex numbers and enqueue source vertex for BFS traversal \n",
    "    queue = [] \n",
    "    queue.append(0) # add the first vertex as source vertex to start the BFS\n",
    "\n",
    "    while len(queue) > 0: \n",
    "\n",
    "        # pop the the first vertex to see its connections\n",
    "        u = queue.pop(0) # queue will push from the end (append) and pop from the head (pop(0))\n",
    "        \n",
    "        # Return false if there is a self-loop \n",
    "        if matrix[u][u] == 1: return False\n",
    "        \n",
    "        for v in range(len(matrix)): # check all connections of the selected vertex\n",
    "            \n",
    "            # if an edge from u to v exists and destination v is not visited, color v into a different group\n",
    "            if matrix[u][v] == 1 and color_list[v] == False: \n",
    "                # if u is 0 then v is 1, or if u is 1 then v is 0\n",
    "                if color_list[u] == 0: \n",
    "                    color_list[v] = 1\n",
    "                else:\n",
    "                    color_list[v] = 0\n",
    "                # push the vertex v into the queue\n",
    "                queue.append(v) \n",
    "\n",
    "            # if an edge from u to v exists but both vertices have the same color, return False\n",
    "            elif matrix[u][v] == 1 and color_list[v] == color_list[u]: return False\n",
    "            \n",
    "    \n",
    "    print(color_list) # view the color list\n",
    "    return True\n",
    "\n",
    "        \n",
    "check_if_bipartite(test_matrix)               \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2- Python program for finding the maximum flow in a graph \n",
    "#### (Edmonds-Karp Algorithm Implimentation of Ford-Fulkerson Algorithm)\n",
    "\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "network of the optimized graph with the max flow:\n",
      "[[ 0. 12. 11.  0.  0.  0.]\n",
      " [ 4.  0.  4. 12.  0.  0.]\n",
      " [ 2. 10.  0.  9. 11.  0.]\n",
      " [ 0.  0.  0.  0.  0. 19.]\n",
      " [ 0.  0.  3.  7.  0.  4.]\n",
      " [ 0.  0.  0.  1.  0.  0.]]\n",
      "max flow:  23.0 \n",
      "\n",
      "original graph: \n",
      " [[ 0. 16. 13.  0.  0.  0.]\n",
      " [ 0.  0. 10. 12.  0.  0.]\n",
      " [ 0.  4.  0.  0. 14.  0.]\n",
      " [ 0.  0.  9.  0.  0. 20.]\n",
      " [ 0.  0.  0.  7.  0.  4.]\n",
      " [ 0.  0.  0.  0.  0.  0.]]\n"
     ]
    }
   ],
   "source": [
    "# Maximum flow implimentation of a network of connections with the help of BFS, \n",
    "# Rendition of the wikipedia solution at https://en.wikipedia.org/wiki/Ford%E2%80%93Fulkerson_algorithm\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "class Graph: \n",
    "   \n",
    "    def __init__(self, graph): \n",
    "        self.graph = np.copy(graph) # graph with max flow capacities from each vertex \n",
    "        \n",
    "    # Returns tne maximum flow from s to t in the given graph \n",
    "    def max_flow_edmonds_karp(self, source, sink): \n",
    "        N, D = self.graph.shape\n",
    "        # initialize a parent array\n",
    "        parent = -np.ones(D, dtype = int) \n",
    "  \n",
    "        # augment the flow while there is path from source to sink, \n",
    "        # for each path between source and sink, the parent array is continually updated with BFS\n",
    "        while self.BFS(source, sink, parent):\n",
    "            \n",
    "            # Find minimum residual capacity (or max flow) of the edges along the path filled by BFS. \n",
    "            min_path_flow = np.inf \n",
    "            t = sink # initialize target as sink \n",
    "            \n",
    "            # from sink to source traverse all parents and find the min flow between all vertices\n",
    "            while(t !=  source): \n",
    "                min_path_flow = min(min_path_flow, self.graph[parent[t]][t]) \n",
    "                t = parent[t] \n",
    "  \n",
    "            # update residual capacities of the edges and reverse edges along the path \n",
    "            v = sink \n",
    "            while(v !=  source): \n",
    "                u = parent[v] \n",
    "                self.graph[u][v] -= min_path_flow \n",
    "                self.graph[v][u] += min_path_flow \n",
    "                v = parent[v] \n",
    "        # the residual network is updated\n",
    "    \n",
    "        # extract the optimized network flow from the optimized residual network\n",
    "        updated_network = self.draw_the_updated_network_flow()\n",
    "        \n",
    "        print('network of the optimized graph with the max flow:')\n",
    "        print(updated_network) # to view the network in equilibrium (when in is equal to out)\n",
    "        # assert that total amount dispatched from source is equal to the total amount received at target \n",
    "        assert(np.sum(updated_network[source , :]) == np.sum(updated_network[: , sink]))\n",
    "        # the max flow into the system at equilibrium is ready to output\n",
    "        return np.sum(updated_network[source, :]) # sum of all inputs from the source vertex into the network\n",
    "    \n",
    " \n",
    "    # simple BFS checks if there is a path from s to t, and returns T or F of a changing graph with a parent array\n",
    "    def BFS(self, source, target, parent): \n",
    "        # parent array is an additional feature that will keep being updated for each time BFS is run\n",
    "  \n",
    "        # Mark all the vertices as not visited \n",
    "        visited =[False]*(len(self.graph)) \n",
    "        \n",
    "        # Create a queue for BFS \n",
    "        queue=[] \n",
    "          \n",
    "        # Mark the source node as visited and enqueue it \n",
    "        queue.append(source) \n",
    "        visited[source] = True\n",
    "           \n",
    "         # Standard BFS Loop \n",
    "        while len(queue) > 0: \n",
    "  \n",
    "            #Dequeue a vertex from queue and print it \n",
    "            u = queue.pop(0) \n",
    "          \n",
    "            # Get all adjacent vertices of the dequeued vertex u that have not been visited, \n",
    "            # mark them visited and then enqueue  \n",
    "            for i in range(len(self.graph[u])): \n",
    "                # check if the index is not visited and graph has a value at [u][i] that is being updated\n",
    "                if visited[i] == False and self.graph[u][i] > 0:\n",
    "                    # append the vertex to the queue, mark it as True, update parent for all connecting vertices \n",
    "                    queue.append(i) \n",
    "                    visited[i] = True\n",
    "                    parent[i] = u \n",
    "        \n",
    "        # if we reached sink in BFS starting from source, then return true, else false \n",
    "        # equilibrium is reached when source vertex output == target vertex input \n",
    "        # when self.graph[target vertex][vertex_at_i_index] == 0 so that visited[t] returns FALSE\n",
    "        return visited[target] # returns True if visited[t] else it returns False (flow conservation)\n",
    "\n",
    "    \n",
    "    def draw_the_updated_network_flow(self):\n",
    "        # transpose of the final residual graph would be the graph with the optimized max flow \n",
    "        n , d = self.graph.shape\n",
    "        updated_graph = np.zeros([d, n], dtype = float)\n",
    "        for i in range(n):\n",
    "            for j in range(d):\n",
    "                updated_graph[j][i] = self.graph[i][j]\n",
    "        return updated_graph\n",
    "    \n",
    "    \n",
    "    \n",
    "test_graph = np.array([[0, 16, 13, 0, 0, 0], \n",
    "                       [0, 0, 10, 12, 0, 0], \n",
    "                       [0, 4, 0, 0, 14, 0], \n",
    "                       [0, 0, 9, 0, 0, 20], \n",
    "                       [0, 0, 0, 7, 0, 4], \n",
    "                       [0, 0, 0, 0, 0, 0]] , dtype = float)\n",
    "  \n",
    "\n",
    "g = Graph(test_graph) \n",
    "print('max flow: ', g.max_flow_edmonds_karp(0, 5), '\\n') \n",
    "print('original graph:', '\\n', np.array(test_graph)) # view the original flow of the network\n",
    " # to view how the graph has been shaped to its final form\n",
    "\n",
    "    \n",
    "# The above implementation of Ford Fulkerson Algorithm is called Edmonds-Karp Algorithm. \n",
    "# The idea of Edmonds-Karp is to use BFS in Ford Fulkerson implementation as BFS which always picks a path \n",
    "# with minimum number of edges. When BFS is used, the worst case time complexity can be reduced to O(VE2).\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x648 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# importing networkx to visualize the connections above\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx \n",
    "plt.figure(figsize =(12, 9))\n",
    "g_visual = nx.DiGraph() \n",
    "\n",
    "for i in range(len(test_graph)): # for each row\n",
    "    for j in range(len(test_graph[0])): # for each column\n",
    "        if test_graph[i][j] > 0: \n",
    "            g_visual.add_edge(i, j)\n",
    "\n",
    "nx.draw_networkx(g_visual, with_label = True, node_color ='red')\n",
    "plt.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3- Maximum bipartite matching algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 1 0 0 0]\n",
      " [1 0 0 1 0 0]\n",
      " [0 0 1 0 0 0]\n",
      " [0 0 1 0 1 0]\n",
      " [1 0 0 0 0 0]\n",
      " [0 0 0 0 0 1]]\n"
     ]
    }
   ],
   "source": [
    "# prepare the bipartite graph test set \n",
    "# ex: where rows are people and columns are available jobs\n",
    "\n",
    "test_matrix =   [[0, 1, 1, 0, 0, 0], \n",
    "                 [1, 0, 0, 1, 0, 0], \n",
    "                 [0, 0, 1, 0, 0, 0], \n",
    "                 [0, 0, 1, 0, 1, 0], \n",
    "                 [1, 0, 0, 0, 0, 0], \n",
    "                 [0, 0, 0, 0, 0, 1]] \n",
    "\n",
    "test_matrix = np.array(test_matrix)\n",
    "print(test_matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# visualize the problem:\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import networkx as nx, numpy as np\n",
    "from networkx.algorithms import bipartite\n",
    "from scipy.sparse import csc_matrix\n",
    "\n",
    "G = nx.Graph()\n",
    "\n",
    "# Give names to the nodes in the two node sets\n",
    "U = [ \"Person{}\".format(i) for i in range(test_matrix.shape[0]) ]\n",
    "V = [ \"Job{}\".format(i) for i in range(test_matrix.shape[1]) ]\n",
    "\n",
    "# Create the graph and add each set of nodes\n",
    "\n",
    "G.add_nodes_from(U, bipartite=0)\n",
    "G.add_nodes_from(V, bipartite=1)\n",
    "\n",
    "# Find the non-zero indices in the biadjacency matrix to connect those nodes\n",
    "G.add_edges_from([(U[i], V[j]) for i, j in zip(*test_matrix.nonzero())]) # ex: 0 0 1 1 2 3 3 5] [1 2 0 3 2 2 3 5]\n",
    "\n",
    "\n",
    "RB = nx.complete_bipartite_graph(6, 6)\n",
    "A  = csc_matrix(bipartite.biadjacency_matrix(RB, row_order=bipartite.sets(RB)[0]))\n",
    "nx.draw_circular(G, node_color = \"cyan\", size = 100, with_labels = True)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 1 0 0 0]\n",
      " [1 0 0 1 0 0]\n",
      " [0 0 1 0 0 0]\n",
      " [0 0 1 0 1 0]\n",
      " [1 0 0 0 0 0]\n",
      " [0 0 0 0 0 1]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(6, [4, 0, 2, 1, 3, 5])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Python program to find maximal bipartite matching. \n",
    "\n",
    "import numpy as np\n",
    "    \n",
    "class bpm: \n",
    "    def __init__(self, graph): \n",
    "        self.graph = graph  # people are the rows (N) and (D) jobs are the columns\n",
    "  \n",
    "\n",
    "    # create a function that returns maximum number of matching \n",
    "    # for each applicant initialize a seen list and see if dfs returns True for this applicant \n",
    "    def max_bipartite_match(self): \n",
    "        # create a job match list that will keep track of which applicant gets which job\n",
    "        # the job array will be filled with the applicant's index number\n",
    "        jobs_array = [-1] * len(self.graph)\n",
    "          \n",
    "        # Count of jobs assigned to applicants \n",
    "        result = 0 \n",
    "        for each_applicant in range(len(self.graph)): # for each applicant, create a seen array\n",
    "              \n",
    "            # Mark all jobs as not seen for next applicant and do a dfs search\n",
    "            seen_jobs = [False] * len(self.graph)\n",
    "              \n",
    "            # if the applicant i can get a job increase the max number of jobs by one\n",
    "            if self.dfs(each_applicant, jobs_array, seen_jobs): \n",
    "                result += 1\n",
    "   \n",
    "        # print(jobs_array) # view the final form of the applicants array that matched people to jobs\n",
    "        return result , jobs_array\n",
    "    \n",
    "    \n",
    "    # create a function that returns true if a matching is posibble while updating the job matching list\n",
    "    def dfs(self, u, jobs_array, seen_jobs): \n",
    "        # for each job, see if there is a connection already and if that job is already seen\n",
    "        for v in range(len(self.graph)): \n",
    "            # if applicant u is interested in job v and v is not seen \n",
    "            if self.graph[u][v] > 0 and seen_jobs[v] == False: \n",
    "                # mark job as visited \n",
    "                seen_jobs[v] = True \n",
    "                # if the job has not been assigned yet or the previously assigned person has an alternative job,\n",
    "                # give this job to the previous person. applicants[v] means which candidate has job v?\n",
    "                # if applicants[v] == -1 or self.dfs(applicants[v], applicants, seen_jobs): \n",
    "                if jobs_array[v] == -1 or self.dfs(jobs_array[v], jobs_array, seen_jobs):\n",
    "                    # update the match list\n",
    "                    jobs_array[v] = u \n",
    "                    return True\n",
    "        return False\n",
    "\n",
    "g = bpm(test_matrix)\n",
    "print(g.graph) # reminder of the graph\n",
    "g.max_bipartite_match() # max number of matches, jobs list just to view who got which job\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Note: This function below will be used in other types of flow problems in the future notebooks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 2, -3, -1, -2]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Find if there is a subarray with zero sum so that the balance points can be extracted from the flow chart \n",
    "# suppose the flow from A to B was recorded as: 4, 2, -3, 1, 6 units every minute. What subarray sum would yield 0?\n",
    "# answer: 2, -3, 1  \n",
    "\n",
    "def find_zero_sum_subarray(flow_arr):\n",
    "    # if sum has any zero OR there are two numbers repeating each other, it means there is a zero sum sub array\n",
    "    # s has all items added in order from first to last index\n",
    "    s = [] \n",
    "    sum_of_items = 0\n",
    "    n = len(flow_arr) \n",
    "    for i in range(n): \n",
    "        sum_of_items += flow_arr[i] \n",
    "        s.append(sum_of_items) \n",
    "        if sum_of_items == 0:\n",
    "            return flow_arr[:i+1]\n",
    "\n",
    "    # if nothing summed up to 0 but all items are summed to some several other values, \n",
    "    # add all items in a dictionary to see if there are any double values\n",
    "    a_dict = {}\n",
    "    for each_sum in range(len(s)):\n",
    "        item = s[each_sum]\n",
    "        if item in a_dict:\n",
    "            a_dict[item] += 1\n",
    "            mark_the_index = each_sum # last seen repetition's index is marked \n",
    "        else:\n",
    "            a_dict[item] = 1\n",
    "    print(s, a_dict) # to view the duplicates if needed\n",
    "   \n",
    "    # mark the values of the dictinary if there are two items that has the same sum value\n",
    "    for k in a_dict.keys():\n",
    "        v = a_dict[k]\n",
    "        if v > 1: # if the item is seen more than once \n",
    "            start_index = s.index(mark_the_index) # python built-in method only shows the first index that item is seen\n",
    "            end_index = mark_the_index \n",
    "            # start index is not included but mark index is included since sub-array summing 0 starts after \n",
    "            return flow_arr[start_index+1 : mark_the_index+1] # sum array : [4, 6, 3, 4, 10] \n",
    "    \n",
    "    return None\n",
    "    \n",
    "test_1 = [4, 2, -3, 1, 6] \n",
    "test_2 = [4, 2, -3, -1, -2, 6]\n",
    "\n",
    "find_zero_sum_subarray(test_2)\n"
   ]
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}