给出C++代码，采用模拟退火算法，流水车间调度问题可以描述为 n 个工件要在 m 台机器上加工，每个工件需要经过 m 道工序，每道工序要求不同的机器加工，每个机器同时只能加工一个工件，一个工件不能同时在不同的机器上加工。工件在机器上的加工时间是给定的。 问题的目标是求n个工件的加工顺序，使总完工时间达到最小。，

以下是采用模拟退火算法解决流水车间调度问题的C++代码：

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <ctime>

using namespace std;

// 工件
struct Job {
    int id;             // 工件编号
    vector<int> time;   // 每道工序的加工时间
};

// 机器
struct Machine {
    int id;             // 机器编号
    int time;           // 机器加工时间
    int jobId;          // 当前加工的工件编号
    int jobStep;        // 当前工件的工序
};

// 计算总完工时间
int calcTotalTime(vector<Job>& jobs, vector<Machine>& machines) {
    int totalTime = 0;
    for (int i = 0; i < jobs.size(); i++) {
        int jobTime = 0;
        for (int j = 0; j < jobs[i].time.size(); j++) {
            int machineId = j;
            int machineTime = jobs[i].time[j];
            int currTime = machines[machineId].time;
            if (machines[machineId].jobId != -1 && machines[machineId].jobId != i) {
                currTime = max(currTime, machines[machineId].time + jobs[machines[machineId].jobId].time[machines[machineId].jobStep]);
            }
            jobTime += currTime - machines[machineId].time;
            machines[machineId].time = currTime + machineTime;
            machines[machineId].jobId = i;
            machines[machineId].jobStep = j;
        }
        totalTime = max(totalTime, jobTime);
    }
    return totalTime;
}

// 生成初始解
vector<int> generateInitSolution(int n) {
    vector<int> solution(n);
    for (int i = 0; i < n; i++) {
        solution[i] = i;
    }
    random_shuffle(solution.begin(), solution.end());
    return solution;
}

// 生成邻域解
vector<int> generateNeighbourSolution(vector<int>& solution) {
    int n = solution.size();
    int i = rand() % n;
    int j = rand() % n;
    while (i == j) {
        j = rand() % n;
    }
    swap(solution[i], solution[j]);
    return solution;
}

// 模拟退火算法
vector<int> simulatedAnnealing(vector<Job>& jobs, vector<Machine>& machines, double T0, double T1, double r) {
    int n = jobs.size();
    vector<int> currSolution = generateInitSolution(n);
    vector<int> bestSolution = currSolution;
    int currCost = calcTotalTime(jobs, machines);
    int bestCost = currCost;
    double T = T0;
    while (T > T1) {
        for (int i = 0; i < 100; i++) {
            vector<int> newSolution = generateNeighbourSolution(currSolution);
            int newCost = calcTotalTime(jobs, machines);
            int delta = newCost - currCost;
            if (delta <= 0 || exp(-delta / T) > ((double) rand()) / RAND_MAX) {
                currSolution = newSolution;
                currCost = newCost;
                if (currCost < bestCost) {
                    bestSolution = currSolution;
                    bestCost = currCost;
                }
            }
        }
        T *= r;
    }
    return bestSolution;
}

int main() {
    srand(time(NULL));
    int n, m;
    cin >> n >> m;
    vector<Job> jobs(n);
    for (int i = 0; i < n; i++) {
        jobs[i].id = i;
        jobs[i].time.resize(m);
        for (int j = 0; j < m; j++) {
            cin >> jobs[i].time[j];
        }
    }
    vector<Machine> machines(m);
    for (int i = 0; i < m; i++) {
        machines[i].id = i;
        machines[i].time = 0;
        machines[i].jobId = -1;
        machines[i].jobStep = -1;
    }
    double T0 = 10000;
    double T1 = 1;
    double r = 0.95;
    vector<int> solution = simulatedAnnealing(jobs, machines, T0, T1, r);
    cout << "最优解为：";
    for (int i = 0; i < n; i++) {
        cout << solution[i] << " ";
    }
    cout << endl;
    cout << "最小完工时间为：" << calcTotalTime(jobs, machines) << endl;
    return 0;
}