Rabbit in Forest: Data Structures and Algorithms Lesson

Welcome to the fascinating world of Data Structures and Algorithms! In this lesson, we'll explore the Rabbit in Forest problem, a classic problem that will help you understand key concepts and techniques. Let's embark on this exciting journey together!

Understanding the Problem

Imagine a vast forest inhabited by rabbits. Each rabbit lives in a burrow and moves only along the horizontal and vertical axes. The forest consists of M rows and N columns. Now, the fun part: there's a hunter who wants to catch as many rabbits as possible. The hunter can move in the same way as the rabbits.

The goal is to find the maximum number of rabbits that the hunter can catch in one night. Let's break down the problem to solve it step by step.

Data Structures and Algorithms Overview

Before we delve into the Rabbit in Forest problem, let's familiarize ourselves with Data Structures and Algorithms.

Data Structures: A way to organize and store data for efficient access and manipulation.

Algorithms: A step-by-step procedure to solve a problem.

Approach to the Problem

We'll approach the Rabbit in Forest problem by following these steps:

Represent the forest as a 2D array.
Use Depth-First Search (DFS) algorithm to traverse the forest.
Keep track of visited cells and rabbits caught by the hunter.

Data Structures

We'll use a 2D array to represent the forest and two additional arrays to keep track of visited cells and rabbits caught.

Forest: A 2D array of size M x N. Each cell contains a value 0 if it's empty, 1 if it's a rabbit, and -1 if it's visited by the hunter.
Visited: A 1D array of size M x N. Initially, all values are 0. When the hunter visits a cell, we mark it 1.
RabbitsCaught: A variable to keep track of the number of rabbits caught.

Algorithms

We'll use the Depth-First Search (DFS) algorithm to traverse the forest. DFS is an algorithm for traversing graphs and trees, and it's useful for exploring the forest while catching rabbits.

DFS Algorithm

Start from an arbitrary cell in the forest.
If the cell is not visited yet (i.e., the value is 0), mark it as visited (change its value to 1).
If the cell contains a rabbit (i.e., the value is 1), increment the RabbitsCaught variable and mark the rabbit as caught (change its value to -1).
Recursively call the DFS algorithm for each of the 8 neighboring cells.

Pseudocode

Here's the pseudocode for the DFS algorithm:

function DFS(row, col):
    if forest[row][col] == 0:
        forest[row][col] = 1
        RabbitsCaught += 1, if forest[row][col] == 1
        DFS(row + 1, col)
        DFS(row - 1, col)
        DFS(row, col + 1)
        DFS(row, col - 1)
        DFS(row + 1, col + 1)
        DFS(row + 1, col - 1)
        DFS(row - 1, col + 1)
        DFS(row - 1, col - 1)

Code Example

Here's a working Python code example that implements the DFS algorithm to solve the Rabbit in Forest problem.

python

def dfs(matrix, visited, row, col):
    if matrix[row][col] == 1:
        visited[row][col] = 1
        global rabbits_caught
        rabbits_caught += 1

    if matrix[row][col] == 0 or visited[row][col] == 1:
        return

    directions = [(-1, 0), (1, 0), (0, -1), (0, 1), (-1, -1), (-1, 1), (1, -1), (1, 1)]
    visited[row][col] = -1
    for dir_row, dir_col in directions:
        dfs(matrix, visited, row + dir_row, col + dir_col)

# Rabbits in Forest problem
matrix = [
    [0, 1, 1, 0, 0],
    [1, 0, 1, 0, 1],
    [0, 1, 0, 1, 0],
    [0, 1, 1, 0, 0],
    [1, 0, 0, 0, 0]
]

# Visited matrix
visited = [[0] * len(matrix[0]) for _ in range(len(matrix))]

# Track rabbits caught
rabbits_caught = 0

# Start DFS from arbitrary cell
dfs(matrix, visited, 0, 0)

# Print the number of rabbits caught
print("Number of rabbits caught:", rabbits_caught)

Quiz

That's it for today's lesson! You now have a solid understanding of the Rabbit in Forest problem and how to use Data Structures and Algorithms to solve it. Keep practicing and exploring different problems to enhance your skills! 🚀🐰🎉