Back to projects

Problem Optimization Metaheuristics

A comprehensive C++ library implementing metaheuristic algorithms for solving complex combinatorial optimization problems.

C++CMakeMakefileGenetic AlgorithmsCat Swarm OptimizationGitGCCClang
Source Code

# Problem Optimization Metaheuristics


A robust collection of C++ implementations designed to solve classical optimization problems using evolutionary computing and swarm intelligence.


Project Overview


This repository serves as a research and development playground for metaheuristic algorithms. It currently implements solutions for classic computer science problems—such as the Knapsack Problem and Job Scheduling—using Genetic Algorithms and Cat Swarm Optimization. The project emphasizes performance, modularity, and clear algorithmic structure.


Technologies Used


  • Language: C++ (C++11/C++17)
  • Build Systems: CMake, Makefile
  • Algorithms: Genetic Algorithms (GA), Cat Swarm Optimization
  • Tools: Git, GCC/Clang

    • Key Features


    1. **Multiple Solvers**: Dedicated solvers for Knapsack, Job Scheduling, and Traveling Salesman problems.

    2. **Evolutionary Operators**: Implements various selection, crossover (Ordered OX), and mutation (Inversion) strategies.

    3. **Performance Oriented**: Written in C++ for maximum computational efficiency.

    4. **Modular Architecture**: Each algorithm and problem domain is isolated for easy study and extension.


    Project Details


    The core goal of this project is to explore how non-deterministic algorithms can find near-optimal solutions to NP-hard problems where exact solutions are computationally expensive.


    ### Supported Problems


  • Knapsack Problem: Maximizing the total value of items in a knapsack without exceeding weight limits.
  • Job Scheduling: Optimizing the sequence of jobs to minimize total completion time.
  • Traveling Salesman (TSP): Finding the shortest possible route visiting a set of cities (implied structure).

    • ### Challenges


  • Premature Convergence: Preventing the genetic algorithm from getting stuck in local optima.
  • Parameter Tuning: Finding the right balance for mutation rates, population size, and crossover probabilities.
  • Computational Complexity: Ensuring the C++ implementations run efficiently even with large population sizes.

    • ### Solutions


  • Configurable Parameters: Extracting key variables (Alpha, Beta, Population Size) into utility files for easy experimentation.
  • Robust Build System: Using CMake to manage dependencies and compilation across different environments.
  • Diverse Operators: Implementing specific crossover methods like Ordered Crossover (OX) to preserve validity in permutation-based problems.

    • Conclusion


    This project demonstrates a deep understanding of algorithmic complexity and C++ software engineering. It provides a solid foundation for students and researchers looking to understand or extend metaheuristic optimization techniques.