Exploring Different Types of Recursion: Functional, Parameterized, and Backtracking

Recursion, a fundamental concept in computer science, offers a way to solve complex problems by breaking them down into smaller instances of the same problem. It involves a function calling itself to solve a smaller version of the original problem. However, not all recursive solutions are the same. In this blog, we'll delve into three distinct types of recursion: Functional Recursion, Parameterized Recursion, and Backtracking. We'll also explore why and when they are used, accompanied by illustrative code snippets.

1. Functional Recursion

Why Functional Recursion? Functional recursion is used when a problem can be divided into smaller, similar subproblems, and the solution is built by aggregating the results of these subproblems. This approach is elegant for problems that exhibit self-similarity and can be expressed in terms of smaller solutions.

Example: Calculating Factorial

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)

print(factorial(5))  # Output: 120

2. Parameterized Recursion

Why Parameterized Recursion? Parameterized recursion is employed when additional parameters are needed to maintain state across recursive calls or modify the behaviour of the function. It's useful for situations where tracking certain information or customizing the function's behaviour at different levels of recursion is essential.

Example: Fibonacci Sequence

def fibonacci(n, memo={}):
    if n in memo:
        return memo[n]
    if n <= 1:
        return n
    else:
        result = fibonacci(n - 1, memo) + fibonacci(n - 2, memo)
        memo[n] = result
        return result

print(fibonacci(7))  # Output: 13

3. Backtracking

Why Backtracking? Backtracking is a technique used to systematically explore possible solutions to a problem by trying out various options and undoing those that lead to invalid or undesirable outcomes. It's ideal for combinatorial optimization problems, puzzles, and situations where an exhaustive search is needed.

Example: Sudoku Solver

pythonCopy codedef is_valid(board, row, col, num):
    # Check if 'num' can be placed at (row, col) in the 'board'
    # ...

def solve_sudoku(board):
    empty_cell = find_empty_cell(board)
    if not empty_cell:
        return True

    row, col = empty_cell
    for num in range(1, 10):
        if is_valid(board, row, col, num):
            board[row][col] = num
            if solve_sudoku(board):
                return True
            board[row][col] = 0  # Backtrack if solution is not possible

    return False

# Test the function
sudoku_board = [
    [5, 3, 0, 0, 7, 0, 0, 0, 0],
    [6, 0, 0, 1, 9, 5, 0, 0, 0],
    [0, 9, 8, 0, 0, 0, 0, 6, 0],
    [8, 0, 0, 0, 6, 0, 0, 0, 3],
    [4, 0, 0, 8, 0, 3, 0, 0, 1],
    [7, 0, 0, 0, 2, 0, 0, 0, 6],
    [0, 6, 0, 0, 0, 0, 2, 8, 0],
    [0, 0, 0, 4, 1, 9, 0, 0, 5],
    [0, 0, 0, 0, 8, 0, 0, 7, 9]
]

if solve_sudoku(sudoku_board):
    for row in sudoku_board:
        print(row)
else:
    print("No solution exists.")

In this example, the function solve_sudoku employs backtracking to fill in the empty cells of the Sudoku board. It tries different numbers in an empty cell, checks whether the placement is valid, and recursively continues until a solution is found or it backtracks when an incorrect placement is encountered.

Output :

[5, 3, 4, 6, 7, 8, 9, 1, 2]
[6, 7, 2, 1, 9, 5, 3, 4, 8]
[1, 9, 8, 3, 4, 2, 5, 6, 7]
[8, 5, 9, 7, 6, 1, 4, 2, 3]
[4, 2, 6, 8, 5, 3, 7, 9, 1]
[7, 1, 3, 9, 2, 4, 8, 5, 6]
[9, 6, 1, 5, 3, 7, 2, 8, 4]
[2, 8, 7, 4, 1, 9, 6, 3, 5]
[3, 4, 5, 2, 8, 6, 1, 7, 9]

In this output, the Sudoku puzzle has been successfully solved, and each row represents a row of the solved Sudoku board. The numbers are placed such that each column, each row, and each 3x3 subgrid contains all the digits from 1 to 9 without repetition.

Conclusion

In conclusion, recursion is a versatile technique with multiple implementations to tackle different problem-solving scenarios. Functional recursion simplifies problems by breaking them down into manageable subproblems. Parameterized recursion enables dynamic state management across recursive calls. Backtracking empowers the systematic exploration of solutions, effectively handling complex scenarios. By understanding and utilizing these types of recursion, programmers can approach a wide range of challenges with confidence and creativity.