【优化求解】矩阵实编码遗传算法 (MRCGA) 求解机组组合 (UC) 问题附Matlab代码

✅作者简介：热爱科研的Matlab仿真开发者，擅长数据处理、建模仿真、程序设计、完整代码获取、论文复现及科研仿真。

🍎 往期回顾关注个人主页：Matlab科研工作室

👇 关注我领取海量matlab电子书和数学建模资料

🍊个人信条：格物致知,完整Matlab代码获取及仿真咨询内容私信。

🔥 内容介绍
摘要：机组组合（UC）问题是电力系统优化运行的核心问题之一，其本质是在满足负荷平衡、系统备用、输电线路传输容量等约束条件下，优化发电机组的启停计划和发电出力分配，以实现发电成本最小化。传统数学优化方法在处理大规模、高维、非线性的UC问题时存在计算复杂度高、收敛性差等局限性。矩阵实编码遗传算法（MRCGA）作为一种智能优化算法，凭借其全局搜索能力、编码方式灵活性和对复杂约束的适应性，在UC问题求解中展现出显著优势。本文系统梳理了MRCGA求解UC问题的研究进展，从算法原理、编码设计、约束处理、求解效率及工程应用等方面进行综合分析，总结了现有研究的贡献与不足，并展望了未来研究方向。

关键词：机组组合问题；矩阵实编码遗传算法；智能优化；电力系统；发电成本

1. 引言
   随着电力系统规模的不断扩大和可再生能源的快速发展，机组组合（Unit Commitment, UC）问题的复杂性显著增加。传统数学优化方法（如动态规划、拉格朗日松弛法、混合整数线性规划等）在处理大规模、高维、非线性的UC问题时，往往面临计算效率低、收敛性差、难以处理复杂约束等问题。智能优化算法（如遗传算法、粒子群优化、模拟退火等）因其全局搜索能力和对复杂问题的适应性，逐渐成为UC问题求解的主流方法之一。

矩阵实编码遗传算法（Matrix Real-Coded Genetic Algorithm, MRCGA）是遗传算法的一种改进形式，其核心思想是将机组启停计划和发电出力分配直接编码为矩阵形式，通过矩阵运算实现遗传操作（选择、交叉、变异），从而避免传统编码方式（如二进制编码、实数编码）在处理高维问题时的维度灾难和计算复杂度问题。MRCGA在UC问题求解中展现出显著优势，已成为该领域的研究热点。

本文系统梳理了MRCGA求解UC问题的研究进展，从算法原理、编码设计、约束处理、求解效率及工程应用等方面进行综合分析，总结了现有研究的贡献与不足，并展望了未来研究方向。

1. MRCGA的基本原理与编码设计
   2.1 MRCGA的基本原理
   MRCGA是遗传算法的一种改进形式，其核心思想是将机组启停计划和发电出力分配直接编码为矩阵形式，通过矩阵运算实现遗传操作。与传统遗传算法相比，MRCGA具有以下特点：

编码方式灵活：采用矩阵编码，可直接表示机组启停状态和发电出力，避免传统编码方式（如二进制编码、实数编码）在处理高维问题时的维度灾难。

遗传操作高效：通过矩阵运算实现选择、交叉、变异等操作，显著提高计算效率。

约束处理方便：矩阵编码可自然嵌入负荷平衡、系统备用、输电线路传输容量等约束条件，便于约束处理。

⛳️ 运行结果

📣 部分代码
% Grey Wolf Optimizer (GWO) for Unit Commitment Problem

% Adapted from MRCGA implementation

clear; clc;

%% Problem Parameters (10-unit system)

N = 10; % Number of units

T = 24; % Time horizon (hours)

% Unit data [Pmax, Pmin, a, b, c, Ton, Toff, HSC, CSC, CST, InitHour]

unitData = [

455, 150, 1000, 16.19, 0.00048, 8, 8, 4500, 9000, 5, 8;

455, 150, 970, 17.26, 0.00031, 8, 8, 5000, 10000, 5, 8;

130, 20, 700, 16.6, 0.002, 5, 5, 550, 1100, 4, -5;

130, 20, 680, 16.5, 0.00211, 5, 5, 560, 1120, 4, -5;

162, 25, 450, 19.7, 0.00398, 6, 6, 900, 1800, 4, -6;

80, 20, 370, 22.26, 0.00712, 3, 3, 170, 340, 2, -3;

85, 25, 480, 27.74, 0.00079, 3, 3, 260, 520, 2, -3;

55, 10, 660, 25.92, 0.00413, 1, 1, 30, 60, 0, -1;

55, 10, 665, 27.27, 0.00222, 1, 1, 30, 60, 0, -1;

55, 10, 670, 27.79, 0.00173, 1, 1, 30, 60, 0, -1

];

% Load demand for 24 hours (MW)

demand = [700, 750, 850, 950, 1000, 1100, 1150, 1200, 1300, 1400, ...

      1450, 1500, 1400, 1300, 1200, 1050, 1000, 1100, 1200, 1400, ...

      1300, 1100, 900, 800];

% Reserve requirement (10% of demand)

reserve = 0.1 * demand;

%% GWO Parameters

params.popSize = 50; % Number of wolves

params.maxIter = 50 * N; % Maximum iterations

params.lambda = 0.6;

params.A = 1e6; % Large constant for fitness

params.delta = 2; % Penalty multiplier

%% Run GWO

fprintf('Starting Grey Wolf Optimizer for Unit Commitment...\n');

fprintf('Population Size: %d\n', params.popSize);

fprintf('Maximum Iterations: %d\n\n', params.maxIter);

[bestSchedule, bestCost, convergence] = GWO(unitData, demand, reserve, params);

%% Display Results

[fuelCost, startupCost, totalCost] = calculateDetailedCost(bestSchedule, unitData);

fprintf('========================================\n');

fprintf(' COST BREAKDOWN \n');

fprintf('========================================\n');

fprintf('Fuel Cost: $%12.2f\n', fuelCost);

fprintf('Startup Cost: $%12.2f\n', startupCost);

fprintf('----------------------------------------\n');

fprintf('Total Cost: $%12.2f\n', totalCost);

fprintf('========================================\n\n');

fprintf('Best Generation Schedule:\n');

displaySchedule(bestSchedule, unitData);

% Display startup pattern

fprintf('\n\nUnit Startup Pattern:\n');

displayStartupPattern(bestSchedule, unitData);

% Plot convergence

figure;

plot(convergence, 'LineWidth', 2);

xlabel('Iteration');

ylabel('Best Cost ($)');

title('Grey Wolf Optimizer Convergence Curve');

grid on;

%% Main GWO Function

function [bestSchedule, bestCost, convergence] = GWO(unitData, demand, reserve, params)

N = size(unitData, 1);

T = length(demand);



% Initialize wolf population

wolves = initializePopulation(params.popSize, N, T, demand, unitData);



% Evaluate initial population

fitness = zeros(params.popSize, 1);

for i = 1:params.popSize

    fitness(i) = evaluateFitness(wolves{i}, unitData, demand, reserve, params);

end



% Identify alpha, beta, and delta wolves (best three solutions)

[sortedFitness, sortIdx] = sort(fitness, 'descend');

alphaSchedule = wolves{sortIdx(1)};

alphaFitness = sortedFitness(1);

betaSchedule = wolves{sortIdx(2)};

betaFitness = sortedFitness(2);

deltaSchedule = wolves{sortIdx(3)};

deltaFitness = sortedFitness(3);



convergence = zeros(params.maxIter, 1);

bestCost = params.A / alphaFitness;



% Main iteration loop

for iter = 1:params.maxIter

    a = 2 - iter * (2 / params.maxIter); % Linearly decreased from 2 to 0



    % Update position of each wolf

    for i = 1:params.popSize

        for t = 1:T

            % Update position with respect to alpha

            r1 = rand(N, 1);

            r2 = rand(N, 1);

            A1 = 2 * a * r1 - a;

            C1 = 2 * r2;

            D_alpha = abs(C1 .* alphaSchedule(:, t) - wolves{i}(:, t));

            X1 = alphaSchedule(:, t) - A1 .* D_alpha;



            % Update position with respect to beta

            r1 = rand(N, 1);

            r2 = rand(N, 1);

            A2 = 2 * a * r1 - a;

            C2 = 2 * r2;

            D_beta = abs(C2 .* betaSchedule(:, t) - wolves{i}(:, t));

            X2 = betaSchedule(:, t) - A2 .* D_beta;



            % Update position with respect to delta

            r1 = rand(N, 1);

            r2 = rand(N, 1);

            A3 = 2 * a * r1 - a;

            C3 = 2 * r2;

            D_delta = abs(C3 .* deltaSchedule(:, t) - wolves{i}(:, t));

            X3 = deltaSchedule(:, t) - A3 .* D_delta;



            % Update wolf position (average of three positions)

            wolves{i}(:, t) = (X1 + X2 + X3) / 3;

        end



        % Repair and ensure feasibility

        wolves{i} = repairSchedule(wolves{i}, unitData, demand, reserve);



        % Evaluate new fitness

        fitness(i) = evaluateFitness(wolves{i}, unitData, demand, reserve, params);

    end



    % Update alpha, beta, and delta

    [sortedFitness, sortIdx] = sort(fitness, 'descend');



    if sortedFitness(1) > alphaFitness

        alphaSchedule = wolves{sortIdx(1)};

        alphaFitness = sortedFitness(1);

    end



    if sortedFitness(2) > betaFitness

        betaSchedule = wolves{sortIdx(2)};

        betaFitness = sortedFitness(2);

    end



    if sortedFitness(3) > deltaFitness

        deltaSchedule = wolves{sortIdx(3)};

        deltaFitness = sortedFitness(3);

    end



    bestCost = params.A / alphaFitness;

    convergence(iter) = bestCost;



    % Display progress

    if mod(iter, 50) == 0

        fprintf('Iteration %d: Best Cost = $%.2f\n', iter, bestCost);

    end

end



bestSchedule = alphaSchedule;

end

%% Initialize Population

function population = initializePopulation(popSize, N, T, demand, unitData)

population = cell(popSize, 1);

for p = 1:popSize

    G = zeros(N, T);

    for t = 1:T

        % Generate random positive numbers

        RAND = rand(N, 1) + 0.1; % Ensure all positive

        PER = RAND / sum(RAND);

        Vt = PER * demand(t);



        % Ensure minimum generation for committed units

        for i = 1:N

            if Vt(i) > unitData(i, 2) * 0.5

                Vt(i) = max(Vt(i), unitData(i, 2));

            end

        end



        G(:, t) = Vt;

    end

    % Repair mechanism

    G = repairSchedule(G, unitData, demand, zeros(1, T));

    population{p} = G;

end

end

%% Repair Schedule

function G = repairSchedule(G, unitData, demand, reserve)

[N, T] = size(G);



for t = 1:T

    % Generation limits and unit status

    for i = 1:N

        Pmax = unitData(i, 1);

        Pmin = unitData(i, 2);

        lambda = 0.6;



        if G(i, t) > Pmax

            G(i, t) = Pmax;

        elseif G(i, t) >= Pmin

            % Keep as is

        elseif G(i, t) > lambda * Pmin

            G(i, t) = Pmin;

        else

            G(i, t) = 0;

        end

    end



    % Ramp rate constraints (if not first hour)

    if t > 1

        for i = 1:N

            Pmax = unitData(i, 1);

            Pmin = unitData(i, 2);

            % Using large ramp rates to allow flexibility

            UR = Pmax; 

            DR = Pmax;



            if G(i, t-1) > 0

                Pimax = min(Pmax, G(i, t-1) + UR);

                Pimin = max(0, G(i, t-1) - DR);

            else

                Pimax = Pmax;

                Pimin = 0;

            end



            if G(i, t) > Pimax

                G(i, t) = Pimax;

            elseif G(i, t) < Pimin && G(i, t) > 0

                if Pimin <= Pmin

                    G(i, t) = Pmin;

                else

                    G(i, t) = Pimin;

                end

            end

        end

    end



    % Check spinning reserve and start units if needed

    onUnits = find(G(:, t) > 0);

    maxCapacity = sum(unitData(onUnits, 1));



    if maxCapacity < demand(t) + reserve(t)

        % Need to start more units

        offUnits = find(G(:, t) == 0);

        for i = 1:length(offUnits)

            idx = offUnits(i);

            G(idx, t) = unitData(idx, 2); % Set to Pmin

            maxCapacity = maxCapacity + unitData(idx, 1);

            if maxCapacity >= demand(t) + reserve(t)

                break;

            end

        end

    end



    % Load balance - must satisfy demand exactly

    G(:, t) = balanceLoad(G(:, t), demand(t), unitData);



    % Round to 1 decimal place after all adjustments

    G(:, t) = round(G(:, t), 1);

end

end

%% Balance Load

function Vt = balanceLoad(Vt, Dt, unitData)

N = length(Vt);

maxIter = 100;

tolerance = 1.0;



for iter = 1:maxIter

    totalGen = sum(Vt);

    deficit = Dt - totalGen;



    if abs(deficit) < tolerance

        break;

    end



    Son = find(Vt > 0);



    if isempty(Son)

        % No units on, start cheapest units

        [~, sortIdx] = sort(unitData(:, 4)); % Sort by b coefficient

        for i = 1:min(3, N)

            idx = sortIdx(i);

            Vt(idx) = unitData(idx, 2); % Pmin

        end

        continue;

    end



    % Find units that can increase generation

    S1 = [];

    for i = 1:length(Son)

        idx = Son(i);

        Pmax = unitData(idx, 1);

        if Vt(idx) < Pmax - 0.1

            S1 = [S1, idx];

        end

    end



    % Find units that can decrease generation

    S2 = [];

    for i = 1:length(Son)

        idx = Son(i);

        Pmin = unitData(idx, 2);

        if Vt(idx) > Pmin + 0.1

            S2 = [S2, idx];

        end

    end



    if deficit > tolerance && ~isempty(S1)

        % Need more generation - distribute among units that can increase

        share = deficit / length(S1);

        for i = 1:length(S1)

            idx = S1(i);

            Pmax = unitData(idx, 1);

            available = Pmax - Vt(idx);

            increase = min(available, share);

            Vt(idx) = Vt(idx) + increase;

        end

    elseif deficit > tolerance

        % Need to start more units

        Soff = find(Vt == 0);

        if ~isempty(Soff)

            % Start cheapest available unit

            costs = unitData(Soff, 4);

            [~, minIdx] = min(costs);

            idx = Soff(minIdx);

            Vt(idx) = unitData(idx, 2);

        end

    elseif deficit < -tolerance && ~isempty(S2)

        % Need less generation - distribute among units that can decrease

        excess = abs(deficit);

        share = excess / length(S2);

        for i = 1:length(S2)

            idx = S2(i);

            Pmin = unitData(idx, 2);

            available = Vt(idx) - Pmin;

            decrease = min(available, share);

            Vt(idx) = Vt(idx) - decrease;

        end

    end

end



% Final adjustment - distribute any remaining imbalance proportionally

totalGen = sum(Vt);

deficit = Dt - totalGen;

if abs(deficit) > 0.1

    Son = find(Vt > 0);

    if ~isempty(Son)

        for idx = Son'

            ratio = Vt(idx) / totalGen;

            Vt(idx) = Vt(idx) + deficit * ratio;

            % Ensure within limits

            Vt(idx) = max(unitData(idx, 2), min(unitData(idx, 1), Vt(idx)));

        end

    end

end

end

%% Evaluate Fitness

function fit = evaluateFitness(G, unitData, demand, reserve, params)

[fuelCost, startupCost, ~] = calculateDetailedCost(G, unitData);

TC = fuelCost + startupCost;



% Add penalty for constraint violations (if any)

penalty = 0;



fit = params.A / (TC + penalty);

end

%% Calculate Detailed Cost

function [fuelCost, startupCost, totalCost] = calculateDetailedCost(G, unitData)

[N, T] = size(G);

fuelCost = 0;

startupCost = 0;



% Calculate fuel costs

for t = 1:T

    for i = 1:N

        if G(i, t) > 0

            a = unitData(i, 3);

            b = unitData(i, 4);

            c = unitData(i, 5);

            FC = a + b * G(i, t) + c * G(i, t)^2;

            fuelCost = fuelCost + FC;

        end

    end

end



% Calculate startup costs

for i = 1:N

    offTime = 0;

    for t = 1:T

        if G(i, t) == 0

            offTime = offTime + 1;

        elseif t > 1 && G(i, t-1) == 0

            % Unit is starting up

            CST = unitData(i, 10); % Cold start time

            HSC = unitData(i, 8);  % Hot start cost

            CSC = unitData(i, 9);  % Cold start cost



            if offTime <= CST

                startupCost = startupCost + HSC;

            else

                startupCost = startupCost + CSC;

            end

            offTime = 0;

        else

            offTime = 0;

        end

    end



    % Check first hour startup

    if G(i, 1) > 0

        initHour = unitData(i, 11);

        if initHour < 0

            % Unit was off initially

            HSC = unitData(i, 8);

            CSC = unitData(i, 9);

            CST = unitData(i, 10);

            if abs(initHour) <= CST

                startupCost = startupCost + HSC;

            else

                startupCost = startupCost + CSC;

            end

        end

    end

end



totalCost = fuelCost + startupCost;

end

%% Display Schedule

function displaySchedule(G, unitData)

[N, T] = size(G);

fprintf('\n%-8s', 'Unit/Hr');

for t = 1:T

    fprintf('%8d', t);

end

fprintf('\n');

fprintf(repmat('-', 1, 8 + 8*T));

fprintf('\n');



for i = 1:N

    fprintf('Unit %-3d', i);

    for t = 1:T

        if G(i, t) > 0

            fprintf('%8.1f', G(i, t));

        else

            fprintf('%8s', '-');

        end

    end

    fprintf('\n');

end



% Display hourly totals and demand

fprintf(repmat('-', 1, 8 + 8*T));

fprintf('\n%-8s', 'Total');

for t = 1:T

    fprintf('%8.1f', sum(G(:, t)));

end

fprintf('\n');

end

%% Display Startup Pattern

function displayStartupPattern(G, unitData)

[N, T] = size(G);



fprintf('\n%-8s %-15s %-15s %-12s\n', 'Unit', 'Startup Hours', 'Off Time', 'Startup Cost');

fprintf(repmat('-', 1, 70));

fprintf('\n');



totalStartupCost = 0;



for i = 1:N

    startupHours = [];

    offTimes = [];

    costs = [];



    % Check initial startup

    if G(i, 1) > 0

        initHour = unitData(i, 11);

        if initHour < 0

            startupHours = [startupHours, 1];

            HSC = unitData(i, 8);

            CSC = unitData(i, 9);

            CST = unitData(i, 10);

            if abs(initHour) <= CST

                offTimes = [offTimes, abs(initHour)];

                costs = [costs, HSC];

                totalStartupCost = totalStartupCost + HSC;

            else

                offTimes = [offTimes, abs(initHour)];

                costs = [costs, CSC];

                totalStartupCost = totalStartupCost + CSC;

            end

        end

    end



    % Check startups during schedule

    offTime = 0;

    for t = 1:T

        if G(i, t) == 0

            offTime = offTime + 1;

        elseif t > 1 && G(i, t-1) == 0

            % Unit is starting up

            startupHours = [startupHours, t];

            HSC = unitData(i, 8);

            CSC = unitData(i, 9);

            CST = unitData(i, 10);



            if offTime <= CST

                offTimes = [offTimes, offTime];

                costs = [costs, HSC];

                totalStartupCost = totalStartupCost + HSC;

            else

                offTimes = [offTimes, offTime];

                costs = [costs, CSC];

                totalStartupCost = totalStartupCost + CSC;

            end

            offTime = 0;

        else

            offTime = 0;

        end

    end



    if ~isempty(startupHours)

        hoursStr = sprintf('%d', startupHours(1));

        for j = 2:length(startupHours)

            hoursStr = [hoursStr, sprintf(', %d', startupHours(j))];

        end



        offStr = sprintf('%d', offTimes(1));

        for j = 2:length(offTimes)

            offStr = [offStr, sprintf(', %d', offTimes(j))];

        end



        costStr = sprintf('$%.0f', costs(1));

        for j = 2:length(costs)

            costStr = [costStr, sprintf(', $%.0f', costs(j))];

        end



        fprintf('Unit %-3d %-15s %-15s %-12s\n', i, hoursStr, offStr, costStr);

    end

end



fprintf(repmat('-', 1, 70));

fprintf('\n%-50s $%.2f\n', 'Total Startup Cost:', totalStartupCost);

end

🔗 参考文献
图片
🏆团队擅长辅导定制多种科研领域MATLAB仿真，助力科研梦：

🌈 各类智能优化算法改进及应用
生产调度、经济调度、装配线调度、充电优化、车间调度、发车优化、水库调度、三维装箱、物流选址、货位优化、公交排班优化、充电桩布局优化、车间布局优化、集装箱船配载优化、水泵组合优化、解医疗资源分配优化、设施布局优化、可视域基站和无人机选址优化、背包问题、 风电场布局、时隙分配优化、 最佳分布式发电单元分配、多阶段管道维修、 工厂-中心-需求点三级选址问题、 应急生活物质配送中心选址、 基站选址、 道路灯柱布置、 枢纽节点部署、 输电线路台风监测装置、 集装箱调度、 机组优化、 投资优化组合、云服务器组合优化、 天线线性阵列分布优化、CVRP问题、VRPPD问题、多中心VRP问题、多层网络的VRP问题、多中心多车型的VRP问题、 动态VRP问题、双层车辆路径规划（2E-VRP）、充电车辆路径规划（EVRP）、油电混合车辆路径规划、混合流水车间问题、 订单拆分调度问题、 公交车的调度排班优化问题、航班摆渡车辆调度问题、选址路径规划问题、港口调度、港口岸桥调度、停机位分配、机场航班调度、泄漏源定位
🌈 机器学习和深度学习时序、回归、分类、聚类和降维
2.1 bp时序、回归预测和分类

2.2 ENS声神经网络时序、回归预测和分类

2.3 SVM/CNN-SVM/LSSVM/RVM支持向量机系列时序、回归预测和分类

2.4 CNN|TCN|GCN卷积神经网络系列时序、回归预测和分类

2.5 ELM/KELM/RELM/DELM极限学习机系列时序、回归预测和分类
2.6 GRU/Bi-GRU/CNN-GRU/CNN-BiGRU门控神经网络时序、回归预测和分类
2.7 ELMAN递归神经网络时序、回归\预测和分类

2.8 LSTM/BiLSTM/CNN-LSTM/CNN-BiLSTM/长短记忆神经网络系列时序、回归预测和分类
2.9 RBF径向基神经网络时序、回归预测和分类

2.10 DBN深度置信网络时序、回归预测和分类
2.11 FNN模糊神经网络时序、回归预测
2.12 RF随机森林时序、回归预测和分类
2.13 BLS宽度学习时序、回归预测和分类
2.14 PNN脉冲神经网络分类
2.15 模糊小波神经网络预测和分类
2.16 时序、回归预测和分类
2.17 时序、回归预测预测和分类
2.18 XGBOOST集成学习时序、回归预测预测和分类
2.19 Transform各类组合时序、回归预测预测和分类
方向涵盖风电预测、光伏预测、电池寿命预测、辐射源识别、交通流预测、负荷预测、股价预测、PM2.5浓度预测、电池健康状态预测、用电量预测、水体光学参数反演、NLOS信号识别、地铁停车精准预测、变压器故障诊断
🌈图像处理方面
图像识别、图像分割、图像检测、图像隐藏、图像配准、图像拼接、图像融合、图像增强、图像压缩感知
🌈 路径规划方面
旅行商问题（TSP）、车辆路径问题（VRP、MVRP、CVRP、VRPTW等）、无人机三维路径规划、无人机协同、无人机编队、机器人路径规划、栅格地图路径规划、多式联运运输问题、 充电车辆路径规划（EVRP）、 双层车辆路径规划（2E-VRP）、 油电混合车辆路径规划、 船舶航迹规划、 全路径规划规划、 仓储巡逻
🌈 无人机应用方面
无人机路径规划、无人机控制、无人机编队、无人机协同、无人机任务分配、无人机安全通信轨迹在线优化、车辆协同无人机路径规划
🌈 通信方面
传感器部署优化、通信协议优化、路由优化、目标定位优化、Dv-Hop定位优化、Leach协议优化、WSN覆盖优化、组播优化、RSSI定位优化、水声通信、通信上传下载分配
🌈 信号处理方面
信号识别、信号加密、信号去噪、信号增强、雷达信号处理、信号水印嵌入提取、肌电信号、脑电信号、信号配时优化、心电信号、DOA估计、编码译码、变分模态分解、管道泄漏、滤波器、数字信号处理+传输+分析+去噪、数字信号调制、误码率、信号估计、DTMF、信号检测
🌈电力系统方面
微电网优化、无功优化、配电网重构、储能配置、有序充电、MPPT优化、家庭用电
🌈 元胞自动机方面
交通流 人群疏散 病毒扩散 晶体生长 金属腐蚀
🌈 雷达方面
卡尔曼滤波跟踪、航迹关联、航迹融合、SOC估计、阵列优化、NLOS识别
🌈 车间调度
零等待流水车间调度问题NWFSP 、 置换流水车间调度问题PFSP、 混合流水车间调度问题HFSP 、零空闲流水车间调度问题NIFSP、分布式置换流水车间调度问题 DPFSP、阻塞流水车间调度问题BFSP