{
"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"colab": {
"provenance": []
},
"kernelspec": {
"name": "python3",
"display_name": "Python 3"
},
"language_info": {
"name": "python"
}
},
"cells": [
{
"cell_type": "markdown",
"source": [
"# Lecture 16 - Breadth First Search\n",
"\n",
"In this lecture, we will discuss -\n",
"\n",
"1. Breadth First Search\n",
"2. Queues - the FIFO data structure\n",
"3. Applications of BFS\n",
"\n",
"Announcements\n",
"\n",
"1. Lab 7 due on Thursday\n",
"2. Exam 2 review session this Friday\n",
"3. Exam 2 - Graphs, DFS, Topological sort, BFS"
],
"metadata": {
"id": "MQKLbKaubzOq"
}
},
{
"cell_type": "markdown",
"source": [
"# Discovery clicker\n",
"\n",
"Scan and use join code 277\n",
"\n",
""
],
"metadata": {
"id": "bZk_tukynU3a"
}
},
{
"cell_type": "markdown",
"source": [
"# Motivation for Breadth First Search\n",
"\n",
"\n",
"**Depth First Search - Shortcomings**\n",
"\n",
"* DFS does not guarantee finding the shortest path between given vertices $s$ and $t$. This is often an important consideration. (Consider finding a flight route from Champaign to Melbourne with the fewest number of hops)\n",
"\n",
"* This is primarily because DFS isn't set up to find the shortest path. It is designed instead to explore the graph in a depth first manner."
],
"metadata": {
"id": "I2qTh-O-Y843"
}
},
{
"cell_type": "markdown",
"source": [
"# Breadth First Search - Main Idea\n",
"\n",
"Breadth first Search explores the graph in a breadth-first manner. The main idea here is to explore all edges of the start vertex before looking at all edges going out of each of its neighbors.\n",
"\n",
"So, in a sense, BFS explores frontiers starting out from the start vertex.\n",
"\n",
"* Start from a vertex of your choice and explore the graph in a breadth oriented manner. That is, go to the vertices at the next level before moving on to further levels.\n",
"\n",
"\n",
"* Repeat this process until there are no new vertices to visit.\n",
"\n",
"Let us look at the working of BFS on undirected graphs.\n",
"\n",
"https://visualgo.net/en/dfsbfs"
],
"metadata": {
"id": "SC9n_ww5bu9v"
}
},
{
"cell_type": "markdown",
"source": [
"#BFS - Implementation\n",
"\n",
"* BFS has a start vertex - and the graph (edges) will be explored relative to this vertex.\n",
"* We want to process all edges going out of start vertex before moving to the next level. So, a DFS style exploration strategy will not work here.\n",
"* In order to process all neighboring vertices of $s$ before exploring their neighbors, we need to use a data structure that prioritizes earlier vertices over later ones. This abstract data structure should implement a First In First Out strategy. Queues are the data structure that do this.\n",
"\n",
"* We will store the parents of each vertex to be able to **trace paths** (this is similar to DFS since the motivation is the same).\n",
"\n",
"* In addition, we will **use a distance list** that monitors the distance of each vertex from $s$ - this is the BIG advantage of BFS - **the exploration style is aimed at finding shortest paths**.\n",
"\n"
],
"metadata": {
"id": "bVx63u-zc9ru"
}
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "W0WtsHBGbs9o",
"outputId": "80e4bae6-9d8a-4cb2-f1ee-d36d09d8a2d0"
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"[0, 1, 1, 2, 2, 2, 3, 3]\n"
]
}
],
"source": [
"#Implementation of Breadth First Search\n",
"\n",
"#input - Graph G, starting vertex s\n",
"#output - distance of each vertex from s\n",
"\n",
"def bfs(G,s):\n",
" # number of vertices in G\n",
" n = len(G)\n",
"\n",
" # initialize dist to be max possible distance\n",
" dist = [n]*len(G)\n",
"\n",
" # noting down the parent of each vertex\n",
" parent = [None]*len(G)\n",
"\n",
" # start the search from s\n",
" dist[s] = 0\n",
" queue = [s]\n",
"\n",
" # start exploring\n",
" while queue != []:\n",
" # remove first element in the queue and explore its neighbors\n",
" u = queue.pop(0)\n",
" for v in G[u]:\n",
" if dist[v] == n:\n",
" # v has not been visited\n",
" dist[v] = dist[u] + 1\n",
" parent[v] = u\n",
" queue.append(v)\n",
"\n",
" # return the list distance storing the shortest distance to each vertex\n",
" return dist\n",
"\n",
"print(bfs([[1,2],[0,3,4,5],[0],[1,5,6],[1,6,7],[1,3],[3,4],[4]],0))"
]
},
{
"cell_type": "markdown",
"source": [
"# BFS observations\n",
"\n",
"1. Shortest paths discovered - BFS exploration strategy ensures that the shortest path from the start vertex $s$ is discovered for each of the other vertices that are reachable from $s$.\n",
"\n",
"2. Unreachable vertices identified - Vertices which are at a distance of $n$ from the starting vertex are clearly unreachable from $s$.\n",
"\n",
"\n",
"3. Linear time - The time complexity of BFS is the same as that of DFS. Since each vertex is pushed to the queue only once, its edges are processed exactly once. This ensures that the time spent per edge is $O(1)$. Since the distance and parent lists require an initiation time of $O(|V|)$, the total time taken is $O(|V| + |E|)$.\n",
"\n"
],
"metadata": {
"id": "pFxHT-rsnbqm"
}
},
{
"cell_type": "markdown",
"source": [
"# Queues\n",
"\n",
"A queue is a collection of objects that operates on the First In First Out principle (FIFO) - the first object in is the first object out.\n",
"\n",
"Queues are typically used for task scheduling - printers that receive multiple requests execute jobs in a first in first out manner. Printers use queues to maintain task requests. Keyboard buffers use a queue to prevent loss of typed data during lags - and since this data must appear in the sequence in which it was typed, buffers use queues.\n",
"\n",
"Queue operations visualization - https://visualgo.net/en/list\n"
],
"metadata": {
"id": "bSwKO2fsc2tX"
}
},
{
"cell_type": "markdown",
"source": [
"**Queues - Python Implementation**\n",
"\n",
"\n",
"\n",
"1. Queues in python can be implemented using lists.\n",
"2. Adding an element - queue.append can be used to add an element to the end of the queue\n",
"3. Removing an element - The elment at the front of the queue can be removed by using queue.pop(0)\n",
"4. Size of the queue - Since python lists store length, one can use len(queue) to find out the number of elements in the queue.\n",
"\n",
"\n",
"Reference - https://www.w3schools.com/python/python_dsa_queues.asp\n",
"\n",
"> Play around with the queue data structure using the code below to better understand how to work with queues.\n",
"\n"
],
"metadata": {
"id": "I0FYZElknfdN"
}
},
{
"cell_type": "code",
"source": [
"# Queues\n",
"\n",
"queue = []\n",
"\n",
"# Enqueue\n",
"queue.append('A')\n",
"queue.append('B')\n",
"queue.append('C')\n",
"print(\"Queue: \", queue)\n",
"\n",
"# Peek\n",
"frontElement = queue[0]\n",
"print(\"Peek: \", frontElement)\n",
"\n",
"# Dequeue\n",
"poppedElement = queue.pop(0)\n",
"print(\"Dequeue: \", poppedElement)\n",
"\n",
"print(\"Queue after Dequeue: \", queue)\n",
"\n",
"\n",
"# Size\n",
"print(\"Size: \", len(queue))\n"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "MyvYppoIcjdA",
"outputId": "e3da4dd4-d277-4ab6-8115-017c043a938e"
},
"execution_count": 2,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Queue: ['A', 'B', 'C']\n",
"Peek: A\n",
"Dequeue: A\n",
"Queue after Dequeue: ['B', 'C']\n",
"Size: 2\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"# BFS : Applications\n",
"\n",
"\n",
"\n",
"* Shortest paths - BFS helps find shortest paths from $s$ to all other vertices.\n",
"* Finding \"close\" vertices - BFS can be used to identify all vertices that are close to $s$ - closeness measured in terms of number of edges needed to reach a vertex.\n",
"* Graph exploration - Like DFS, BFS uses linear time to explore the connectivity structure of a graph.\n",
"* Finding paths - Like DFS, BFS helps identify whether there exists any path from one vertex to another.\n",
"* Cycle Detection - BFS can be used to detect the existence of cycles.\n",
"\n"
],
"metadata": {
"id": "7n0_-hqS-emP"
}
}
]
}