Lecture 21: Recursive Matrix Multiplication & Radix Sort

Recursive Matrix Multiplication (Block Method)

Split two n×n matrices into four n/2×n/2 submatrices and combine results using divide & conquer.

Input A

Input B

Result C

The visualization shows block splitting, recursive multiplication of subblocks, and accumulation into C. This uses the classical 8 subproduct approach (no Strassen optimizations here).

## Block Multiplication — Code (recursive)

```cpp
// Assumes n is a power of 2. A,B,C are n×n arrays; alpha,beta scalars omitted for clarity.
void addMatrix(double **X, double **Y, double **R, int n);
void subMatrix(double **X, double **Y, double **R, int n);

void matMulRecursive(double **A, double **B, double **C, int n) {
    if (n == 1) { // base case
        C[0][0] += A[0][0] * B[0][0];
        return;
    }
    int m = n/2;
    
    // Allocate temporary matrices for sub-results or use in-place accumulation
    // For clarity, assuming we have functions to get submatrices
    
    // C11 = A11*B11 + A12*B21
    matMulRecursive(A, B, C, m);  // A11*B11 -> C11
    matMulRecursive(&A[0][m], &B[m][0], C, m);  // A12*B21 -> C11
    
    // C12 = A11*B12 + A12*B22
    matMulRecursive(A, &B[0][m], &C[0][m], m);  // A11*B12 -> C12
    matMulRecursive(&A[0][m], &B[m][m], &C[0][m], m);  // A12*B22 -> C12
    
    // C21 = A21*B11 + A22*B21
    matMulRecursive(&A[m][0], B, &C[m][0], m);  // A21*B11 -> C21
    matMulRecursive(&A[m][m], &B[m][0], &C[m][0], m);  // A22*B21 -> C21
    
    // C22 = A21*B12 + A22*B22
    matMulRecursive(&A[m][0], &B[0][m], &C[m][m], m);  // A21*B12 -> C22
    matMulRecursive(&A[m][m], &B[m][m], &C[m][m], m);  // A22*B22 -> C22
}
```

Notes: implement careful indexing or use pointers to sub-blocks to avoid copying when possible.

Radix Sort (LSD example)

Radix sort sorts integers by processing digits (least significant digit first for LSD). It repeatedly uses a stable counting sort on digits.

Enter a list of non-negative integers (comma separated):

Radix Sort Visualization

Visualization shows each digit pass and the stable bucketed order.

## Invert Binary Tree

**Problem:** Given the root of a binary tree, invert the tree and return its root.

**Example:**

```
Input:
     4
   /   \
  2     7
 / \   / \
1   3 6   9

Output:
     4
   /   \
  7     2
 / \   / \
9   6 3   1
```

---

**Recursive Solution:**

```cpp
TreeNode* invertTree(TreeNode* root) {
    // Base case: empty tree
    if (!root) return nullptr;

// Recursive case: invert left and right subtrees
    TreeNode* left = invertTree(root->left);
    TreeNode* right = invertTree(root->right);

// Swap the left and right children
    root->left = right;
    root->right = left;

return root;
}
```

---

**Algorithm Steps:**

1. **Base Case:** If node is null, return null
2. **Recursive Calls:** Invert left and right subtrees
3. **Swap:** Exchange left and right child pointers
4. **Return:** Root of inverted tree

---

**Visualization:** Step-by-step tree inversion

---

**Time Complexity:** O(n) - visits each node once
**Space Complexity:** O(h) - recursion depth equals tree height

Invert Binary Tree

## Class Exercise: Chess Game with Polymorphism

**Objective:** Design and implement a simple chess game framework using object-oriented programming principles, specifically demonstrating polymorphism through inheritance and virtual methods.

**Requirements:**
- Create a base `Piece` class with common attributes (color, position) and virtual methods for movement validation and piece representation.
- Derive specific piece classes: `Pawn`, `Rook`, `Knight`, `Bishop`, `Queen`, `King`.
- Each derived class should override the virtual methods to implement piece-specific movement rules.
- Implement a basic `Board` class to manage pieces and validate moves.
- Demonstrate polymorphism by storing pieces in a collection of base class pointers and calling virtual methods.

**Key Concepts:**
- Inheritance: Base `Piece` class with derived classes for each piece type.
- Polymorphism: Virtual methods for `isValidMove()` and `getSymbol()`.
- Encapsulation: Private member variables with public accessors.

---

**Sample Code Outline:**

```cpp
#include <iostream>
#include <vector>
#include <string>

enum Color { WHITE, BLACK };

class Piece {
protected:
    Color color;
    int x, y;  // position on board
public:
    Piece(Color c, int x, int y) : color(c), x(x), y(y) {}
    virtual ~Piece() {}
    virtual bool isValidMove(int newX, int newY, const std::vector<std::vector<Piece*>>& board) const = 0;
    virtual char getSymbol() const = 0;
    Color getColor() const { return color; }
    void setPosition(int newX, int newY) { x = newX; y = newY; }
    int getX() const { return x; }
    int getY() const { return y; }
};

class Pawn : public Piece {
public:
    Pawn(Color c, int x, int y) : Piece(c, x, y) {}
    bool isValidMove(int newX, int newY, const std::vector<std::vector<Piece*>>& board) const override {
        // Implement pawn movement rules
        int direction = (color == WHITE) ? 1 : -1;
        if (newX == x + direction && newY == y && !board[newX][newY]) return true;
        // Add capture logic, first move, etc.
        return false;
    }
    char getSymbol() const override { return (color == WHITE) ? 'P' : 'p'; }
};

// Implement other pieces similarly...

class Board {
private:
    std::vector<std::vector<Piece*>> board;
public:
    Board() {
        board.resize(8, std::vector<Piece*>(8, nullptr));
        // Initialize pieces
    }
    bool movePiece(int fromX, int fromY, int toX, int toY) {
        if (!board[fromX][fromY]) return false;
        if (board[fromX][fromY]->isValidMove(toX, toY, board)) {
            board[toX][toY] = board[fromX][fromY];
            board[fromX][fromY] = nullptr;
            board[toX][toY]->setPosition(toX, toY);
            return true;
        }
        return false;
    }
    void printBoard() const {
        for (int i = 7; i >= 0; i--) {
            for (int j = 0; j < 8; j++) {
                if (board[i][j]) std::cout << board[i][j]->getSymbol() << " ";
                else std::cout << ". ";
            }
            std::cout << std::endl;
        }
    }
};

int main() {
    Board chessBoard;
    // Initialize and play game
    return 0;
}
```

---

**Tasks:**
1. Complete the implementation of all piece classes with proper movement rules.
2. Add check/checkmate detection.
3. Implement turn-based gameplay.
4. Extend with additional features like castling, en passant, promotion.

**Discussion Points:**
- How does polymorphism simplify adding new piece types?
- What are the advantages of using virtual methods for movement validation?
- How would you handle special moves like castling or pawn promotion?

Quiz 1

Q1: Radix sort is stable: true or false?