top of page

Algorithms & Data Structures

Course: University of Michigan EECS 280: Programming and Introductory Data Structures (Winter 2022)

Image Resizing (C++)                                                                                                                                                     January 2022 – February 2022

Focus Areas: Computer Vision, Dynamic Programming, Seam Carving Algorithm

  • Developed a content-aware image resizing program using the seam carving algorithm to remove low-importance pixels.

  • Implemented an energy matrix to calculate pixel importance, ensuring structure preservation during resizing.

  • Designed a dynamic programming approach to compute the minimal vertical seam and optimize image reduction.

  • Built an interactive command-line tool that supports image resizing while maintaining visual quality.

  • Optimized performance by leveraging pointer arithmetic and matrix indexing for fast pixel access.

​

Euchre AI & Game Simulation (C++)                                                                                                                                 February 2022 – March 2022

Focus Areas: Object-Oriented Programming (OOP), Game AI, Design Patterns

  • Developed a Euchre card game simulation with AI and human players.

  • Implemented OOP principles using inheritance, polymorphism, and abstract data types (ADTs).

  • Designed AI decision-making for trump selection, card ranking, and trick-taking strategies.

  • Built a command-line game driver to handle shuffling, dealing, and round logic.

  • Validated AI behavior through unit testing and game rule enforcement.

​

Course: University of Michigan EECS 281: Data Structures and Algorithms (Fall 2022)

Pathfinding Optimization in Multi-Dimensional Maps (C++)                                                                                           August 2022 – September 2022

Focus Areas: Graph Search, Shortest Path Algorithms, Stack & Queue-Based Search

  • Implemented graph search algorithms to navigate a maze-like castle and rescue the Countess.

  • Developed two pathfinding approaches:

    • ​Queue-based (Breadth-First Search - BFS) for shortest pathfinding.

    • Stack-based (Depth-First Search - DFS) for alternative route exploration.

  • Designed a castle navigation system with walls, minions, and warp pipes, ensuring valid movement constraints.

  • Optimized search efficiency by tracking visited locations and preventing redundant exploration.

  • Handled multiple input and output modes, supporting both map-based and coordinate-based navigation representations.

  • Implemented route tracing mechanisms to reconstruct the optimal path after search completion.

 

Zombie Apocalypse Simulation (C++)                                                                                                                          September 2022 – October 2022

Focus Areas: Priority Queues, Graph Algorithms, Real-Time Simulation

  • Designed a real-time simulation where a player defends against waves of zombies using priority queues and streaming algorithms.

  • Developed a priority queue system to manage zombie movement and attack prioritization based on ETA-based scheduling.

  • Optimized survival strategy, ensuring optimal arrow usage based on distance, speed, and health attributes.

  • Designed three priority queue implementations:

    • ​Sorted Priority Queue – Fast access with sorted list maintenance.

    • Binary Heap Priority Queue – Logarithmic-time insertion and deletion.

    • Pairing Heap Priority Queue – Self-adjusting heap for fast merging and updates.

  • Implemented custom comparison functors, allowing flexible priority ordering for queue operations.

  • Validated queue correctness and efficiency through rigorous testing and debugging.

 

Gameplay Optimization (C++)                                                                                                                                   November 2022 – December 2022

Focus Areas: Graph Algorithms, Minimum Spanning Tree (MST), Traveling Salesperson Problem (TSP), Branch and Bound

  • Implemented Prim’s and Kruskal’s algorithms to compute the Minimum Spanning Tree (MST) for efficient pathfinding.

  • Developed heuristic-based FASTTSP approximation for the Traveling Salesperson Problem (TSP) to find near-optimal solutions.

  • Implemented an exact Branch and Bound (BnB) algorithm to compute the optimal TSP tour, ensuring the shortest possible path.

  • Developed an effective bounding function to prune non-optimal search branches, reducing computational complexity.

  • Optimized memory usage with efficient adjacency matrix representation for small graphs.

bottom of page