C++ 在NEH算法中使用STL的低性能

我对NEH算法有问题。我实现了它，但速度非常慢，我不知道问题出在哪里。你能证实我做错了什么，是什么导致性能不好吗？这是我的密码：

#include <iostream>
#include <map>
#include <sstream>
#include <limits>
#include <vector>
#include <fstream>
#include <list>
#include <algorithm>
#include <numeric>
#include <queue>
#include <memory>

template <typename T>
class Matrix
{
public:
    Matrix(unsigned int rowsNum, unsigned int columnsNum) :m_rows(rowsNum), m_columns(columnsNum){ resize(rowsNum, columnsNum); };
    T& operator()(unsigned int r, unsigned int c) { return m_data[r*columns() + c]; }
    const T& operator()(unsigned int r, unsigned int c) const { return m_data[r*columns() + c]; }
    unsigned int rows() const { return m_rows; }
    unsigned int columns() const { return m_columns; }
    Matrix<T> operator+(const Matrix<T>& matrix) const;
private:
    void resize(unsigned int rowsNum, unsigned int colsNum);
    std::unique_ptr<T[]> m_data;
    unsigned int m_rows;
    unsigned int m_columns;
};

template <typename T>
Matrix<T> Matrix<T>::operator+(const Matrix& matrix) const
{

}

template <typename T>
void Matrix<T>::resize(unsigned int rowsNum, unsigned int colsNum)
{
    m_rows = rowsNum;
    m_columns = colsNum;
    m_data.reset(new T[rowsNum*colsNum]);
}

class Task
{
public:
    Task(unsigned int ordNum = 0) :m_ordNum(ordNum) { }
    unsigned int readFromFile(std::istream& is);
    unsigned int totalTasksTime() const;
    unsigned int ordNum() const { return m_ordNum; }
    unsigned int machinesNum() const { return m_params.size(); }
    unsigned int machineTaskTime(unsigned int machineNum) const { return m_params[machineNum - 1]; }
protected:
    std::vector<unsigned int> m_params;
    unsigned int m_ordNum;
    unsigned int m_totalTasksTime;
};


unsigned int Task::totalTasksTime() const
{
    return m_totalTasksTime;
}

unsigned int Task::readFromFile(std::istream& is)
{
    std::string line;
    while (is.peek() == '\n') // omija puste linie
        is.get();

    std::getline(is, line);

    m_params.clear();

    std::istringstream istr(line);
    unsigned int i = 1;
    while (istr)
    {
        int taskNum, taskTime;
        istr >> taskNum >> taskTime;
        if (istr)
        {
            if (i == m_params.size() + 1)
                m_params.push_back(taskTime);
            else
                throw "Zly numer indesku maszyny - musza być po kolei";

            i++;
        }
    }
    m_totalTasksTime = std::accumulate(m_params.begin(), m_params.end(), 0);
    return m_params.size();
}


class Instance
{
public:
    Instance() { }
    Instance(const std::string& name) :m_name(name) { }
    void readFromFile(std::istream& is);
    const std::string& name() const { return m_name; }
    void name(std::string& newName) { m_name = newName; }
    void neh(std::list<unsigned int>& permutation, unsigned int &totalTime) const;
    const Task* getTask(unsigned int taskNum) const { return &m_tasks[taskNum]; }
private:
    unsigned int calculateTotalTime(const std::list<unsigned int>& permutationList, unsigned int bestTimeFound) const;
    std::vector<Task> m_tasks;
    std::string m_name;
};


typedef std::map<unsigned int, unsigned int> MapIterator;
typedef std::vector<Task>::const_iterator TaskVecIterator;

bool compareTasksPtrBySumTime(const Task* t1, const Task* t2)
{
    unsigned int t1TotalTime = t1->totalTasksTime(), t2TotalTime = t2->totalTasksTime();

    bool w1 = t1TotalTime < t2TotalTime, w2 = t1TotalTime == t2TotalTime && t1->ordNum() > t2->ordNum();

    return w1 || w2;
}

void Instance::neh(std::list<unsigned int>& permutation, unsigned int &totalTime) const
{
    // sortowanie zadań po całkowitym czasie wykonania 
    std::list<const Task*> sortedTaskList;
    for (unsigned int i = 0; i < m_tasks.size(); i++)
        sortedTaskList.push_back(&m_tasks[i]);

    sortedTaskList.sort(compareTasksPtrBySumTime);

    while (!sortedTaskList.empty()) // 
    {
        const Task* taskPtr = sortedTaskList.back(); sortedTaskList.pop_back();
        unsigned int taskNum = taskPtr->ordNum();

        std::list<unsigned int>::iterator bestPosition = permutation.begin();
        unsigned int bestTotalTime = std::numeric_limits<unsigned int>::max();
        permutation.push_front(taskNum);
        for (std::list<unsigned int>::iterator it = permutation.begin(); // szukanie najlepszej pozycji
             it != permutation.end(); it++)
          {
            unsigned int currentTotalTime = calculateTotalTime(permutation, bestTotalTime);

            if (bestTotalTime > currentTotalTime)
              {
            bestTotalTime = currentTotalTime;
            bestPosition = it;
              }
            auto nextIt = it; nextIt++;
            if (nextIt != permutation.end())
              std::swap(*it, *nextIt);
          }

        totalTime = bestTotalTime;
        permutation.insert(bestPosition, taskNum);
        permutation.pop_back();

    }
    std::cout << "Ukonczono:" << name() << std::endl;
}

unsigned int Instance::calculateTotalTime(const std::list<unsigned int>& permutationList, unsigned int bestTimeFound) const
{
    unsigned int rows = m_tasks[*permutationList.begin() - 1].machinesNum() + 1, columns = permutationList.size() + 1;
    Matrix<unsigned int> matrix(rows, columns);
    unsigned int totalTime = 0;

    for (unsigned int c = 0; c < columns; c++)
        matrix(0, c) = 0;

    for (unsigned int r = 0; r < rows; r++)
        matrix(r, 0) = 0;

    std::list<unsigned int>::const_iterator it = permutationList.begin();
    for (unsigned int c = 1; c < columns; c++)
    {
        unsigned int taskNum = *it;
        for (unsigned int r = 1; r < rows; r++)
            (matrix(r, c) = std::max(matrix(r, c - 1), matrix(r - 1, c)) + m_tasks[taskNum - 1].machineTaskTime(r));// >bestTimeFound;
        //  return std::numeric_limits<unsigned int>::max();

        it++;
    }

    return matrix(rows - 1, columns - 1);

}

void Instance::readFromFile(std::istream& is)
{
    int taskNum, machineNum;

    is >> taskNum >> machineNum;

    for (int i = 0; i < taskNum; i++)
    {
        Task task(i + 1);
        task.readFromFile(is);
        if (is)
            m_tasks.push_back(task);
    }
}


class InstanceVector
{
public:
    void readFromFile(std::istream& is);
    void neh(std::list< std::list<unsigned int> >& result) const;
    void neh(std::ostream& os) const;
private:
    std::vector<Instance> m_instances;
};

void InstanceVector::readFromFile(std::istream& is)
{
    while (is)
    {
        std::string name;
        is >> name;
        Instance instance(name);
        instance.readFromFile(is);
        std::list<unsigned int> l;
        unsigned int totalTime;
        if (is)
          m_instances.push_back(instance);
    }
}


void InstanceVector::neh(std::list< std::list<unsigned int> >& results) const
{
    std::vector<Instance>::const_iterator it;
    for (it = m_instances.begin(); it != m_instances.end(); it++)
    {
        std::list<unsigned int> resultInstance;
        unsigned int totalTimeInstance;
        it->neh(resultInstance, totalTimeInstance);
        results.push_back(resultInstance);
    }
}

void InstanceVector::neh(std::ostream& os) const
{
    std::list< std::list<unsigned int> > results;
    for (std::vector<Instance>::const_iterator it = m_instances.begin();
        it != m_instances.end(); it++)
    {
        std::list<unsigned int> resultInstance;
        unsigned int totalTimeInstance;
        it->neh(resultInstance, totalTimeInstance);
        results.push_back(std::move(resultInstance));
    }

    for (std::list< std::list<unsigned int> >::const_iterator it = results.begin();
        it != results.end(); it++)
    {
        for (std::list<unsigned int>::const_iterator itPermutation = it->begin(); itPermutation != it->end(); itPermutation++)
            os << *itPermutation << " ";
        os << std::endl;
    }
}


int main(int argc, char* argv[])
{
    InstanceVector instanceVec;
    std::ifstream input("bench_fs.txt");
    if (input.is_open())
        instanceVec.readFromFile(input);

    std::ofstream output("output.txt");
    instanceVec.neh(output);
    std::cin.get();
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
模板
类矩阵
{
公众：
矩阵（unsigned int rowsNum，unsigned int columnsum）：m_行（rowsNum），m_列（columnsum）{调整大小（rowsNum，columnsNum）；}；
运算符（）（无符号整数r，无符号整数c）{返回m_数据[r*列（）+c]；}
const T&operator（）（unsigned int r，unsigned int c）const{return m_data[r*columns（）+c]；}
unsigned int rows（）常量{return m_rows；}
unsigned int columns（）常量{return m_columns；}
矩阵算子+（常数矩阵&矩阵）常数；
私人：
void resize（unsigned int rowsNum，unsigned int colsNum）；
std：：唯一的ptr m_数据；
无符号整数m_行；
无符号整数m_列；
};
模板
矩阵：：运算符+（常数矩阵和矩阵）常数
{
}
模板
void Matrix:：resize（无符号整数rowsNum、无符号整数colsNum）
{
m_rows=rowsNum；
m_列=colsNum；
m_data.reset（新的T[rowsNum*colsNum]）；
}
课堂任务
{
公众：
任务（unsigned int ordNum=0）：m_ordNum（ordNum）{}
未签名的int readFromFile（std:：istream&is）；
无符号整数totalTasksTime（）常量；
无符号int ordNum（）常量{return m_ordNum；}
unsigned int machinesNum（）常量{return m_params.size（）；}
unsigned int-machineTaskTime（unsigned int-machineNum）常量{返回m_参数[machineNum-1]；}
受保护的：
std：：向量m_参数；
无符号整数m_ordNum；
无符号整数m_totalTasksTime；
};
未签名整型任务：：totalTasksTime（）常量
{
返回m_totalTasksTime；
}
未签名int任务：：readFromFile（std：：istream&is）
{
std：：字符串行；
而（is.peek（）='\n'）//omija puste linie
是。get（）；
std:：getline（is，line）；
m_参数清除（）；
std:：istringstream istr（线）；
无符号整数i=1；
while（istr）
{
int taskNum，taskTime；
istr>>taskNum>>taskTime；
如果（istr）
{
如果（i==m_参数大小（）+1）
m_参数推回（任务时间）；
其他的
抛出“Zly numer indesku maszyny-musza byćpo kolei”；
i++；
}
}
m_totalTasksTime=std:：accumulate（m_params.begin（），m_params.end（），0）；
返回m_参数大小（）；
}
类实例
{
公众：
实例（）{}
实例（const std:：string&name）：m_name（name）{}
void readFromFile（std:：istream&is）；
常量std:：string&name（）常量{return m_name；}
void name（std:：string&newName）{m_name=newName；}
void neh（标准：：列表和排列，无符号整数和总时间）常量；
const Task*getTask（unsigned int taskNum）const{return&m_tasks[taskNum]；}
私人：
unsigned int calculateTotalTime（const std:：list&permutationList，unsigned int bestTimeFound）const；
std：：向量m_任务；
std：：字符串m_名称；
};
typedef std:：map映射器；
typedef std:：vector:：const_迭代器taskvecierator；
bool comparetasktrbysumtime（常量任务*t1，常量任务*t2）
{
无符号整数t1TotalTime=t1->totalTasksTime（），t2TotalTime=t2->totalTasksTime（）；
boolw1=t1TotalTimeordNum（）>t2->ordNum（）；
返回w1 | | w2；
}
void实例：：neh（标准：：列表和置换、无符号整数和总时间）常量
{
//索托瓦尼·扎达丹波·卡什科维蒂姆-捷克-维科纳尼亚省（sortowanie zadałpo całkowitym czasie wykonania）
std：：列表分类任务列表；
for（unsigned int i=0；iordNum（）；
std:：list:：迭代器bestPosition=permutation.begin（）；
unsigned int bestTotalTime=std:：numeric_limits:：max（）；
排列。推前（taskNum）；
for（std:：list:：iterator it=permutation.begin（）；//szukanie najlepszej pozycji
it！=置换.end（）；it++）
{
unsigned int currentTotalTime=calculateTotalTime（排列，bestTotalTime）；
如果（bestTotalTime>currentTotalTime）
{
bestTotalTime=currentTotalTime；
最佳位置=它；
}
auto nextIt=it；nextIt++；
if（nextIt！=permutation.end（））
标准：交换（*it，*nextIt）；
}
totalTime=bestTotalTime；
排列。插入（最佳位置，taskNum）；
排列。pop_back（）；
}
std:：cout taskNum>>machineNum；
for（int i=0；i&结果）常数；
无效neh（标准：ostream&os）常数；
私人：
std：：向量m_实例；
};
void InstanceVector:：readFromFile（std:：istream&is）
{
while（is）
{
std：：字符串名；
是>>名称；
实例（名称）；
readFromFile（is）；
std：：列表l；
无符号整数总时间；
如果（是）
m_实例。推回（实例）；
}
}
void InstanceVector:：neh（std:：list&结果）常量
{
std:：vector:：const_迭代器it；
for（it=m_instances.begin（）；it！=m_instances.end（）；it++）
{
std：：列表结果状态；
无符号整数totalTimeInstance；
it->neh（结果状态，totalTimeInstance）；
结果：推回（resultInstance）；
}
}
void InstanceVector:：neh（std:：ostream&os）常量
{
标准：：列表<标准：：列表>结果；
对于（std:：vector:：const_迭代器it=m_instances.begin（）；
它！=m_实例