Посоветуйте как реализовать job shop scheduling

// JobShop_2.0.cpp : Defines the entry point for the console application.
#include "stdafx.h"
#include <iostream>
#include <cstdlib>
#include <deque>
#include <algorithm>
#include <windows.h>
 
using namespace std;
 
struct Operation {
    int num;
    int time;
};
 
struct OperationQueue {
    int start;
    int task_num;
    int time;
    int wait;
    int priority;
};
 
class Machine {
private:
    bool state;
    int operation_num;
    deque<OperationQueue> task_queue;
public: 
    Machine(int op, bool st) : operation_num(op), state(st){}
 
    void SetStartTime(int currentTime) {
        task_queue.front().start = currentTime;
    }
 
    int GetStartTime() {
        return task_queue.front().start;
    }
 
    void SetPriority()
    {
        if (!task_queue.empty()) {
            for (int i = 0; i < task_queue.size(); i++) {
                //task_queue.at(i).priority = (task_queue.at(i).time + task_queue.at(i).wait) / 2;
                task_queue.at(i).priority = task_queue.at(i).time;
            }
        }
    }
    
    bool EmptyQueue() {
        bool temp = task_queue.empty();
        return temp;
    }
 
    int GetOperationNr() { //???
        return operation_num;
    }
 
    void SortQueue()
    {
        if (!task_queue.empty()) {
            sort(task_queue.begin(), task_queue.end(), [](const OperationQueue& a, const OperationQueue& b) {
                return a.priority < b.priority;
            });
        }
    }
 
    void AddOperation(int task, int time) {
        OperationQueue nq;
        nq.task_num = task;
        nq.time = time;
        nq.wait = 0;
        nq.priority = NULL;
 
        task_queue.push_back(nq);
    }
 
    void GetInfoAboutMachine() {
        cout << "state : " << state << " | operation number : " << operation_num << endl;
    }
 
    void GetInfoAboutQueue() {
        for (size_t i = 0; i < task_queue.size(); i++)
        {
            cout << "index : " << i << " | task number : "<< task_queue.at(i).task_num << " | time : "<< task_queue.at(i).time << " | priority : " << task_queue.at(i).priority << " | start : " << task_queue.at(i).start << endl;
        }
    }
 
    int GetTime() {
        return  task_queue.front().time;
    }
 
    void ReduceTime(int min) {
        task_queue.front().time -= min;
    }
 
    bool GetState() {
        return state;
    }
 
    void SetState(bool st) {
        state = st;
    }
 
    int GetFree() {
        int nr;
        state = true;
        nr = task_queue.front().task_num;
        task_queue.pop_front();
 
        return nr;
    }
    
};
 
 
int main()
{
    bool tasks_state = true;
    int num_machines;
    int num_tasks;
    int current_time = 0;
 
    deque<deque<Operation>> tasks;
    deque<Machine> machines;
 
    cin >> num_tasks >> num_machines;
 
    //num_tasks = 3; 
    //num_machines = 3;
    //int array_temp[5][6] = { {0, 2, 1, 2, 2, 2 }, {1, 2, 0, 4, 2, 1}, {2, 4, 1, 2, 0, 1},{ 1, 4, 2, 2, 0, 4 }};
 
    //вводим данные для deque->deque->structure
    for (unsigned i = 0; i < num_tasks; i++) {
        deque<Operation> temp_deque;
        tasks.push_back(temp_deque);
 
        for (int j = 0; j < num_machines; j++) { 
            Operation temp_structure;
 
            //temp_structure.num = array_temp[i][j];
            //temp_structure.time = array_temp[i][j+1];
 
            cin >> temp_structure.num >> temp_structure.time;
            tasks.at(i).push_back(temp_structure);
        }
    }
 
    //создаем список машин deque->Machine class
    for (int j = 0; j < num_machines; j++) {
        Machine temp_machine(j, false);
        machines.push_back(temp_machine);
    }
 
    //Заполняем очереди в машинах
    for (unsigned i = 0; i < num_tasks; i++) {
        for (int j = 0; j < num_machines; j++) {
            if (tasks.at(i).front().num == j){
                machines.at(j).AddOperation(i, tasks.at(i).front().time);
                tasks.at(i).pop_front();
                break;
            }
        }
    }
 
    //Отсортируем перед началом
    for (int j = 0; j < num_machines; j++) {
        machines.at(j).SetPriority();
        machines.at(j).SortQueue();
 
        //Установим текущее время, для начала операций
        machines.at(j).SetStartTime(current_time);
    }
 
    deque<deque<int>> results;
    results.resize(tasks.size());
 
    while (tasks_state)
    {
 
        int min_time = 100000;
        int machine_index;
 
        //Если машина свободна то добавляю задачу в очередь, сортирую и устанавливаю время. 
        for (int i = 0; i < tasks.size(); i++) {
            for (unsigned j = 0; j < machines.size(); j++) {
                if (machines.at(j).GetState()) {
                    if (!(tasks.at(i).empty()) && (tasks.at(i).front().num == machines.at(j).GetOperationNr())) {
                        machines.at(j).AddOperation(i, tasks.at(i).front().time);
                        machines.at(j).SetState(false);
                        tasks.at(i).pop_front();
 
                        machines.at(j).SetPriority();
                        machines.at(j).SortQueue();
 
                        machines.at(j).SetStartTime(current_time);
                        break;
                    }
                }
            }
        }
 
        //Проверка есть ли в tasks задачи
        tasks_state = false;
        for (int i = 0; i < tasks.size(); i++) {
            if (!(tasks.at(i).empty())) {
                tasks_state = true;
            }
        }
 
        //Нахожу минимальный квант времени 
        for (int i = 0; i < machines.size(); i++) {
            if (!machines.at(i).EmptyQueue()) {
                if ((machines.at(i).GetTime() < min_time)) {
 
                    machine_index = i;
                    min_time = machines.at(i).GetTime();
                }
            }
        }
 
        //Обновляю время работы в каждой машине - т.е. просто отнимаю мин время 
        for (size_t i = 0; i < machines.size(); i++) {
            if (!machines.at(i).EmptyQueue()) {
                machines.at(i).ReduceTime(min_time);
                //Проверяю закончила ли машина работу над операцией 
                if (machines.at(i).GetTime() == 0) {
                    int del_start_time = machines.at(i).GetStartTime();
                    int del_index = machines.at(i).GetFree();
                    //в machine добавить время и записать в результирующий массив
                    results.at(del_index).push_back(del_start_time);
                    machines.at(i).SetState(true);
                }
            }
        }
 
        current_time += min_time;
    }
 
    for (size_t i = 0; i < results.size(); i++) {
        for (size_t j = 0; j < results.at(i).size(); j++) {
            cout << results.at(i).at(j) << " ";
        }
        cout << endl;
    }
 
    system("pause");
    return 0;
}