Can you fix the output of the Gantt chart in the code and the output of the gantt chart should be the same in the image below? Badly need to fix it :( Thank you! Code: #include #include #include #include struct Process {     int processId;     int burstTime;     int priority; }; void print_gantt_chart(const std::vector>& gantt_chart) {     std::cout << "Gantt Chart:" << std::endl;     std::cout << "----------------------------------------------------------------------------" << std::endl;     std::cout << "| ";     for (const auto& process : gantt_chart) {         std::cout << "P" << process.first << " | ";     }     std::cout << std::endl;     std::cout << "----------------------------------------------------------------------------" << std::endl;     std::cout << "0  ";     int currentTime = 0;     for (const auto& process : gantt_chart) {         currentTime += process.second;         if (std::to_string(currentTime).length() == 1)             std::cout << "  " << currentTime << "  ";         else             std::cout << "  " << currentTime << " ";     }     std::cout << std::endl; } void multiLevelQueueScheduling(const std::vector& processes, int quantumTime) {     std::queue fcfs;     std::queue rr;     std::queue priority;     // Splitting the processes into different queues based on priority     for (const auto& process : processes) {         if (process.priority == 1)             fcfs.push(process);         else if (process.priority == 2)             rr.push(process);         else if (process.priority == 3 || process.priority == 4)             priority.push(process);     }     std::vector> gantt_chart;     while (!fcfs.empty() || !rr.empty() || !priority.empty()) {                  // FCFS Scheduling         if (!fcfs.empty()) {             Process process = fcfs.front();             fcfs.pop();             int executionTime = std::min(quantumTime, process.burstTime);             process.burstTime -= executionTime;             gantt_chart.emplace_back(process.processId, executionTime);             if (process.burstTime > 0)                 fcfs.push(process);         }         // RR Scheduling         if (!rr.empty()) {             Process process = rr.front();

Can you fix the output of the Gantt chart in the code and the output of the gantt chart should be the same in the image below? Badly need to fix it :( Thank you!

Code:

#include <iostream>
#include <queue>
#include <string>
#include <vector>

struct Process {
    int processId;
    int burstTime;
    int priority;
};

void print_gantt_chart(const std::vector<std::pair<int, int>>& gantt_chart) {
    std::cout << "Gantt Chart:" << std::endl;
    std::cout << "----------------------------------------------------------------------------" << std::endl;
    std::cout << "| ";

    for (const auto& process : gantt_chart) {
        std::cout << "P" << process.first << " | ";
    }

    std::cout << std::endl;
    std::cout << "----------------------------------------------------------------------------" << std::endl;
    std::cout << "0  ";

    int currentTime = 0;
    for (const auto& process : gantt_chart) {
        currentTime += process.second;
        if (std::to_string(currentTime).length() == 1)
            std::cout << "  " << currentTime << "  ";
        else
            std::cout << "  " << currentTime << " ";
    }

    std::cout << std::endl;
}

void multiLevelQueueScheduling(const std::vector<Process>& processes, int quantumTime) {
    std::queue<Process> fcfs;
    std::queue<Process> rr;
    std::queue<Process> priority;

    // Splitting the processes into different queues based on priority
    for (const auto& process : processes) {
        if (process.priority == 1)
            fcfs.push(process);
        else if (process.priority == 2)
            rr.push(process);
        else if (process.priority == 3 || process.priority == 4)
            priority.push(process);
    }

    std::vector<std::pair<int, int>> gantt_chart;

    while (!fcfs.empty() || !rr.empty() || !priority.empty()) {
        
        // FCFS Scheduling
        if (!fcfs.empty()) {
            Process process = fcfs.front();
            fcfs.pop();

            int executionTime = std::min(quantumTime, process.burstTime);
            process.burstTime -= executionTime;

            gantt_chart.emplace_back(process.processId, executionTime);

            if (process.burstTime > 0)
                fcfs.push(process);
        }

        // RR Scheduling
        if (!rr.empty()) {
            Process process = rr.front();
            rr.pop();

            int executionTime = std::min(quantumTime, process.burstTime);
            process.burstTime -= executionTime;

            gantt_chart.emplace_back(process.processId, executionTime);

            if (process.burstTime > 0)
                rr.push(process);
        }

        // Priority Scheduling
        if (!priority.empty()) {
            Process process = priority.front();
            priority.pop();

            int executionTime = std::min(quantumTime, process.burstTime);
            process.burstTime -= executionTime;

            gantt_chart.emplace_back(process.processId, executionTime);

            if (process.burstTime > 0)
                priority.push(process);
        }
    }

    print_gantt_chart(gantt_chart);

    std::vector<int> completionTime(processes.size());
    std::vector<int> turnaroundTime(processes.size());
    std::vector<int> waitingTime(processes.size());

    int currentEndTime = 0;
    for (const auto& process : gantt_chart) {
        int processIndex = process.first - 1;
        currentEndTime += process.second;
        completionTime[processIndex] = currentEndTime;
        turnaroundTime[processIndex] = completionTime[processIndex];
        waitingTime[processIndex] = turnaroundTime[processIndex] - processes[processIndex].burstTime;
    }

    std::cout << "\nProcess\t\tBurst Time\t\tPriority\t\tCompletion Time\t\tTurnaround Time\t\tWaiting Time" << std::endl;
    for (const auto& process : processes) {
        int processIndex = process.processId - 1;
        std::cout << "P" << process.processId << "\t\t" << process.burstTime << "\t\t\t" << process.priority << "\t\t\t"
            << completionTime[processIndex] << "\t\t\t" << turnaroundTime[processIndex] << "\t\t\t" << waitingTime[processIndex] << std::endl;
    }

    float avgWaitingTime = 0;
    float avgTurnaroundTime = 0;
    for (const auto& process : processes) {
        avgWaitingTime += waitingTime[process.processId - 1];
        avgTurnaroundTime += turnaroundTime[process.processId - 1];
    }

    avgWaitingTime /= processes.size();
    avgTurnaroundTime /= processes.size();

    std::cout << std::endl;
    std::cout << "Average Waiting Time: " << avgWaitingTime << std::endl;
    std::cout << "Average Turnaround Time: " << avgTurnaroundTime << std::endl;
}

int main() {
    std::vector<Process> processes = {
        {1, 8, 4},
        {2, 6, 1},
        {3, 1, 2},
        {4, 9, 2},
        {5, 3, 3}
    };

    int quantumTime = 2;

    multiLevelQueueScheduling(processes, quantumTime);

    return 0;
}