【优化求解】矩阵实编码遗传算法 (MRCGA) 求解机组组合 (UC) 问题附Matlab代码-阿里云开发者社区

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

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

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

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

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

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

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

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

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

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

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

热门文章

最新文章

相关电子书

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

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

热门文章

最新文章

相关电子书