Upload 15 files

code/long-term prediction/CNN.py

@@ -0,0 +1,177 @@
+import os
+import pandas as pd
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader, Dataset
+import numpy as np
+from glob import glob
+
+# 参数设置
+DATA_DIR = "G:\\loading_benchmark\\bakFlightLoadData\\bakFlightLoadData"  # 数据文件夹路径
+AIRCRAFT_MODELS = ["A320", "B737", "A330", "A350", "B777", "B787"]
+TRAIN_DAYS = 40
+TEST_DAYS = 47
+
+# 数据处理
+def load_and_process_data(data_dir, aircraft_models):
+    all_files = sorted(glob(os.path.join(data_dir, "BAKFLGITH_LOADDATA*.csv")))
+    data_by_day = []
+
+    for file in all_files:
+        df = pd.read_csv(file, header=None, usecols=[0, 1, 3], names=["fid", "fleetId", "weight"],
+                         encoding='ISO-8859-1')
+        daily_data = {}
+        for model in aircraft_models:
+            model_data = df[df["fleetId"].str.contains(model, na=False)]
+            if not model_data.empty:
+                daily_avg = model_data["weight"].mean()  # 每天的平均载货重量
+                daily_data[model] = daily_avg
+        data_by_day.append(daily_data)
+
+    return data_by_day
+
+
+def prepare_data(data_by_day, train_days, test_days):
+    """
+    准备按机型的训练和测试数据，每天计算平均值，分为训练和测试集。
+    """
+    train_data = data_by_day[:train_days]
+    test_data = data_by_day[:train_days + test_days]
+
+    train_processed = {model: [] for model in AIRCRAFT_MODELS}
+    test_processed = {model: [] for model in AIRCRAFT_MODELS}
+
+    for daily_data in train_data:
+        for model in AIRCRAFT_MODELS:
+            if model in daily_data:
+                train_processed[model].append(daily_data[model])
+
+    for daily_data in test_data:
+        for model in AIRCRAFT_MODELS:
+            if model in daily_data:
+                test_processed[model].append(daily_data[model])
+
+    return train_processed, test_processed
+
+
+# 自定义数据集
+class AircraftDataset(Dataset):
+    def __init__(self, data):
+        self.data = data
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        return torch.tensor([self.data[idx]], dtype=torch.float32)
+
+
+# CNN 模型
+class CNNSPredictor(nn.Module):
+    def __init__(self, input_size, output_size):
+        super(CNNSPredictor, self).__init__()
+        self.conv1 = nn.Conv1d(in_channels=1, out_channels=64, kernel_size=1, padding=1)
+        self.pool = nn.MaxPool1d(2)
+        self.dropout = nn.Dropout(p=0.01)
+        self.conv2 = nn.Conv1d(in_channels=64, out_channels=32, kernel_size=1, padding=1)
+        self.fc1 = nn.Linear(32, 64)  # 全连接层，用于输出之前的隐藏层
+        self.fc2 = nn.Linear(64, output_size)
+
+    def forward(self, x):
+        # 输入 x 形状: [batch_size, 1, seq_len]
+        x = self.conv1(x)
+        x = self.pool(x)
+        x = self.dropout(x)
+        x = self.conv2(x)
+        x = self.pool(x)
+        x = self.dropout(x)
+        x = torch.flatten(x, 1)  # 展平
+        x = self.fc1(x)
+        x = self.fc2(x)
+        return x
+
+
+# 训练和测试函数
+def train_model(train_loader, model, criterion, optimizer, epochs=50):
+    model.train()
+    for epoch in range(epochs):
+        total_loss = 0
+        for batch in train_loader:
+            optimizer.zero_grad()
+            batch = batch.unsqueeze(1)  # [batch, 1, seq_len] 扩展维度，适应 Conv1d
+            predictions = model(batch)
+            loss = criterion(predictions, batch)
+            loss.backward()
+            optimizer.step()
+            total_loss += loss.item()
+        print(f"Epoch {epoch + 1}/{epochs}, Loss: {total_loss:.4f}")
+
+
+def test_model(test_loader, model):
+    model.eval()
+    predictions = []
+    true_values = []
+    with torch.no_grad():
+        for batch in test_loader:
+            batch = batch.unsqueeze(1)  # [batch_size, 1, seq_len]
+            preds = model(batch)
+            predictions.append(preds.squeeze().numpy())
+            true_values.append(batch.squeeze().numpy())
+
+    mae_list = []
+    mape_list = []
+    acc = 0
+    for i in range(len(true_values)):
+        mae = np.abs(predictions[i] - true_values[i])  # 平均绝对误差
+        mape = np.abs(predictions[i] - true_values[i])/true_values[i]
+        mae_list.append(mae)
+        mape_list.append(mape)
+        if mape * 100 < 7:
+            acc += 1
+    return true_values, predictions, mae_list, mape_list, acc / len(true_values)
+
+
+# 主程序
+if __name__ == "__main__":
+    # 加载数据
+    data_by_day = load_and_process_data(DATA_DIR, AIRCRAFT_MODELS)
+
+    # 按机型分开训练和测试
+    results = {}
+    for model in AIRCRAFT_MODELS:
+        print(f"Processing model: {model}")
+        fw = open(f'G:\\loading_benchmark\\result\\pred_{model}_cnn2', 'w')
+        # 准备训练和测试数据
+        train_processed, test_processed = prepare_data(data_by_day, TRAIN_DAYS, TEST_DAYS)
+        train_data = train_processed[model]
+        test_data = test_processed[model]
+
+        if not train_data or not test_data:
+            print(f"No data available for {model}")
+            continue
+
+        train_dataset = AircraftDataset(train_data)
+        test_dataset = AircraftDataset(test_data)
+        train_loader = DataLoader(train_dataset, batch_size=8, shuffle=True)
+        test_loader = DataLoader(test_dataset, batch_size=1, shuffle=False)
+
+        # 定义模型和训练
+        input_size = 1  # 仅平均载货重量作为输入
+        output_size = 1  # 预测平均载货重量
+        model_instance = CNNSPredictor(input_size, output_size)
+
+        criterion = nn.MSELoss()
+        optimizer = torch.optim.Adam(model_instance.parameters(), lr=0.001)
+
+        # 训练模型
+        train_model(train_loader, model_instance, criterion, optimizer, epochs=600)
+
+        # 测试模型
+        true, predictions, mae, mse, acc = test_model(test_loader, model_instance)
+        for i in range(len(predictions)):
+            fw.write(f"{true[i]}\t{predictions[i]}\t{mae[i]}\t{mse[i]}\t{acc}\n")
+
+    # 输出结果
+    # for model, preds in results.items():
+    #     print(f"Results for {model}:")
+    #     print(preds)

code/long-term prediction/LSTM.py

@@ -0,0 +1,189 @@
+
+
+import os
+import pandas as pd
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader, Dataset
+import numpy as np
+from glob import glob
+from einops import rearrange
+# 参数设置
+DATA_DIR = "G:\\loading_benchmark\\bakFlightLoadData\\bakFlightLoadData"  # 数据文件夹路径
+# AIRCRAFT_MODELS = ['A320-232D', 'A320-23B', 'A320-21B', 'A320-23A', 'A320-21A', 'A320-27B', 'A320-27C', 'A320-21D', 'A320-27A', 'A320-214S']
+AIRCRAFT_MODELS = ["A320", "B737", "A330", "A350", "B777", "B787"]
+# AIRCRAFT_MODELS = ["A320"]
+TRAIN_DAYS = 40
+TEST_DAYS = 47
+
+
+# 数据处理
+def load_and_process_data(data_dir, aircraft_models):
+    all_files = sorted(glob(os.path.join(data_dir, "BAKFLGITH_LOADDATA*.csv")))
+    data_by_day = []
+
+    for file in all_files:
+        df = pd.read_csv(file, header=None, usecols=[0, 1, 3], names=["fid", "fleetId", "weight"],
+                         encoding='ISO-8859-1')
+        daily_data = {}
+        for model in aircraft_models:
+            model_data = df[df["fleetId"].str.contains(model, na=False)]
+            if not model_data.empty:
+                # model_data =  model_data.groupby("fid")["weight"].transform('sum')
+                daily_avg = model_data["weight"].mean()  # 每天的平均载货重量
+                # grouped_data = model_data.groupby("fid")["weight"].sum()
+                # # 计算该机型的平均载货重量（按航班ID的总重量平均）
+                # daily_avg = grouped_data.mean()
+                daily_data[model] = daily_avg
+        data_by_day.append(daily_data)
+
+    return data_by_day
+
+
+def prepare_data(data_by_day, train_days, test_days):
+    """
+    准备按机型的训练和测试数据，每天计算平均值，分为训练和测试集。
+    """
+    train_data = data_by_day[:train_days]
+    test_data = data_by_day[:train_days + test_days]
+
+    train_processed = {model: [] for model in AIRCRAFT_MODELS}
+    test_processed = {model: [] for model in AIRCRAFT_MODELS}
+
+    for daily_data in train_data:
+        for model in AIRCRAFT_MODELS:
+            if model in daily_data:
+                train_processed[model].append(daily_data[model])
+
+    for daily_data in test_data:
+        for model in AIRCRAFT_MODELS:
+            if model in daily_data:
+                test_processed[model].append(daily_data[model])
+
+    return train_processed, test_processed
+
+
+# 自定义数据集
+class AircraftDataset(Dataset):
+    def __init__(self, data):
+        self.data = data
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        return torch.tensor([self.data[idx]], dtype=torch.float32)
+
+
+# LSTM 模型
+class LSTMPredictor(nn.Module):
+    def __init__(self, input_size, hidden_size, num_layers, output_size):
+        super(LSTMPredictor, self).__init__()
+        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True,bidirectional=False)
+        self.dropout = nn.Dropout(p=0.05)
+        self.conv2 = nn.Conv1d(in_channels=64, out_channels=32, kernel_size=1, padding=1)
+        self.fc1 = nn.Linear(64,32)  # 全连接层，用于输出之前的隐藏层
+        self.fc = nn.Linear(32, output_size)
+
+    def forward(self, x):
+        out, _ = self.lstm(x)
+
+        # out = self.dropout(out)
+        x = out
+        x = self.dropout(x)
+        x = self.fc1(x)
+        x = self.fc(x)
+        # out = self.fc(out[:, -1, :])
+        return x
+
+
+# 训练和测试函数
+def train_model(train_loader, model, criterion, optimizer, epochs=50):
+    model.train()
+    optimizer.zero_grad()
+    for epoch in range(epochs):
+        total_loss = 0
+        for batch in train_loader:
+            optimizer.zero_grad()
+            batch = batch.unsqueeze(1)  # [batch, seq_len=1, features]
+            predictions = model(batch)
+            loss = criterion(predictions, batch)
+            loss.backward()
+            optimizer.step()
+            total_loss += loss.item()
+        print(f"Epoch {epoch + 1}/{epochs}, Loss: {total_loss:.4f}")
+
+
+def test_model(test_loader, model):
+
+    predictions = []
+    true_values = []
+    with torch.no_grad():
+        for batch in test_loader:
+            batch = batch.unsqueeze(1)  # [batch_size, seq_len=1, features]
+            preds = model(batch)
+            predictions.append(preds.squeeze().numpy())
+            true_values.append(batch.squeeze().numpy())
+
+
+    acc = 0
+    # 计算误差
+    mae_list = []
+    mape_list = []
+    for i in range(len(true_values)):
+        mae = np.abs(predictions[i] - true_values[i])  # 平均绝对误差
+        mape = np.abs(predictions[i] - true_values[i])/true_values[i]
+        mae_list.append(mae)
+        mape_list.append(mape)
+        if mape*100 < 7:
+            acc+=1
+        # print(f"Test MAE: {mae:.4f}, Test MSE: {mape:.4f}")
+    return true_values,predictions, mae_list, mape_list,acc/len(true_values)
+
+
+# 主程序
+if __name__ == "__main__":
+    # 加载数据
+    data_by_day = load_and_process_data(DATA_DIR, AIRCRAFT_MODELS)
+
+    # 按机型分开训练和测试
+    results = {}
+    for model in AIRCRAFT_MODELS:
+        print(f"Processing model: {model}")
+        fw = open('G:\\loading_benchmark\\result\\pred_'+model+'_lstm3', 'w')
+        # 准备训练和测试数据
+        train_processed, test_processed = prepare_data(data_by_day, TRAIN_DAYS, TEST_DAYS)
+        print(train_processed[model])
+        train_data = train_processed[model]
+        test_data = test_processed[model]
+
+        if not train_data or not test_data:
+            print(f"No data available for {model}")
+            continue
+        print(train_data)
+        train_dataset = AircraftDataset(train_data)
+        test_dataset = AircraftDataset(test_data)
+        train_loader = DataLoader(train_dataset, batch_size=8, shuffle=True)
+        test_loader = DataLoader(test_dataset, batch_size=1, shuffle=False)
+
+        # 定义模型和训练
+        input_size = 1  # 仅平均载货重量作为输入
+        hidden_size = 64
+        num_layers = 2
+        output_size = 1  # 预测平均载货重量
+        model_instance = LSTMPredictor(input_size, hidden_size, num_layers, output_size)
+
+        criterion = nn.MSELoss()
+        optimizer = torch.optim.Adam(model_instance.parameters(), lr=0.001)
+
+        # 训练模型
+        train_model(train_loader, model_instance, criterion, optimizer, epochs=500)
+
+        # 测试模型
+        true,predictions,mae,mse,acc = test_model(test_loader, model_instance)
+        for i in range(len(predictions)):
+            fw.write(str(true[i])+"\t"+str(predictions[i])+"\t"+str(mae[i])+"\t"+str(mse[i])+"\t"+str(acc)+"\n")
+    # 输出结果
+    # for model, preds in results.items():
+    #     print(f"Results for {model}:")
+    #     print(preds)

code/long-term prediction/regression.py

@@ -0,0 +1,184 @@
+
+
+import os
+import pandas as pd
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader, Dataset
+import numpy as np
+from glob import glob
+
+# 参数设置
+DATA_DIR = "G:\\loading_benchmark\\bakFlightLoadData\\bakFlightLoadData"  # 数据文件夹路径
+AIRCRAFT_MODELS = ["A320", "B737", "A330", "A350", "B777", "B787"]
+# AIRCRAFT_MODELS = ["A320"]
+TRAIN_DAYS = 40
+TEST_DAYS = 47
+
+
+# 数据处理
+def load_and_process_data(data_dir, aircraft_models):
+    all_files = sorted(glob(os.path.join(data_dir, "BAKFLGITH_LOADDATA*.csv")))
+    data_by_day = []
+
+    for file in all_files:
+        df = pd.read_csv(file, header=None, usecols=[0, 1, 3], names=["fid", "fleetId", "weight"],
+                         encoding='ISO-8859-1')
+        daily_data = {}
+        for model in aircraft_models:
+            model_data = df[df["fleetId"].str.contains(model, na=False)]
+            if not model_data.empty:
+                daily_avg = model_data["weight"].mean()  # 每天的平均载货重量
+                daily_data[model] = daily_avg
+        data_by_day.append(daily_data)
+
+    return data_by_day
+
+
+def prepare_data(data_by_day, train_days, test_days):
+    """
+    准备按机型的训练和测试数据，每天计算平均值，分为训练和测试集。
+    """
+    train_data = data_by_day[:train_days]
+    test_data = data_by_day[:train_days + test_days]
+
+    train_processed = {model: [] for model in AIRCRAFT_MODELS}
+    test_processed = {model: [] for model in AIRCRAFT_MODELS}
+
+    for daily_data in train_data:
+        for model in AIRCRAFT_MODELS:
+            if model in daily_data:
+                train_processed[model].append(daily_data[model])
+
+    for daily_data in test_data:
+        for model in AIRCRAFT_MODELS:
+            if model in daily_data:
+                test_processed[model].append(daily_data[model])
+
+    return train_processed, test_processed
+
+
+# 自定义数据集
+class AircraftDataset(Dataset):
+    def __init__(self, data):
+        self.data = data
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        return torch.tensor([self.data[idx]], dtype=torch.float32)
+
+
+# LSTM 模型
+class LSTMPredictor(nn.Module):
+    def __init__(self, input_size, hidden_size, num_layers, output_size):
+        super(LSTMPredictor, self).__init__()
+        # self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True,bidirectional=True)
+        self.fc = nn.Linear(input_size, output_size)
+
+    def forward(self, x):
+        # out, _ = self.lstm(x)
+        out = self.fc(x)
+        return out
+
+
+# 训练和测试函数
+def train_model(train_loader, model, criterion, optimizer, epochs=50):
+    model.train()
+    epoch = 0
+    while True:
+        epoch +=1
+        total_loss = 0
+        for batch in train_loader:
+            optimizer.zero_grad()
+            batch = batch.unsqueeze(1)  # [batch, seq_len=1, features]
+            predictions = model(batch)
+            loss = criterion(predictions, batch)
+            loss.backward()
+            optimizer.step()
+            total_loss += loss.item()
+        _,_,_,_,acc = test_model(train_loader, model,8)
+        if epoch % 50 == 0:
+            print(acc)
+            if acc > 0.50:
+                break
+        print(f"Epoch {epoch + 1}, Loss: {total_loss:.4f}")
+
+
+def test_model(test_loader, model,batchsize):
+    model.eval()
+    predictions = []
+    true_values = []
+    with torch.no_grad():
+        for batch in test_loader:
+            batch = batch.unsqueeze(1)  # [batch_size, seq_len=1, features]
+            preds = model(batch)
+            predictions.append(preds.squeeze().numpy())
+            true_values.append(batch.squeeze().numpy())
+
+
+    acc = 0
+    # 计算误差
+    mae_list = []
+    mape_list = []
+    for i in range(len(true_values)):
+        mae = np.abs(predictions[i] - true_values[i])  # 平均绝对误差
+        mape = np.abs(predictions[i] - true_values[i])/true_values[i]
+        mae_list.append(mae)
+        mape_list.append(mape)
+        if batchsize == 1:
+            if mape*100 < 7:
+                acc+=1
+        else:
+            for i in range(len(mape)):
+                if mape[i]*100 < 7:
+                    acc+=1
+        # print(f"Test MAE: {mae:.4f}, Test MSE: {mape:.4f}")
+    return true_values,predictions, mae_list, mape_list,acc/(len(true_values)*batchsize)
+
+# 主程序
+if __name__ == "__main__":
+    # 加载数据
+    data_by_day = load_and_process_data(DATA_DIR, AIRCRAFT_MODELS)
+
+    # 按机型分开训练和测试
+    results = {}
+    for model in AIRCRAFT_MODELS:
+        print(f"Processing model: {model}")
+        fw = open('G:\\loading_benchmark\\result\\pred_'+model+'_reg1', 'w')
+        # 准备训练和测试数据
+        train_processed, test_processed = prepare_data(data_by_day, TRAIN_DAYS, TEST_DAYS)
+        train_data = train_processed[model]
+        test_data = test_processed[model]
+
+        if not train_data or not test_data:
+            print(f"No data available for {model}")
+            continue
+
+        train_dataset = AircraftDataset(train_data)
+        test_dataset = AircraftDataset(test_data)
+        train_loader = DataLoader(train_dataset, batch_size=8, shuffle=True)
+        test_loader = DataLoader(test_dataset, batch_size=1, shuffle=False)
+
+        # 定义模型和训练
+        input_size = 1  # 仅平均载货重量作为输入
+        hidden_size = 64
+        num_layers = 2
+        output_size = 1  # 预测平均载货重量
+        model_instance = LSTMPredictor(input_size, hidden_size, num_layers, output_size)
+
+        criterion = nn.MSELoss()
+        optimizer = torch.optim.Adam(model_instance.parameters(), lr=0.001)
+
+        # 训练模型
+        train_model(train_loader, model_instance, criterion, optimizer, epochs=200)
+
+        # 测试模型
+        true,predictions,mae,mse,acc = test_model(test_loader, model_instance,1)
+        for i in range(len(predictions)):
+            fw.write(str(true[i])+"\t"+str(predictions[i])+"\t"+str(mae[i])+"\t"+str(mse[i])+"\t"+str(acc)+"\n")
+    # 输出结果
+    # for model, preds in results.items():
+    #     print(f"Results for {model}:")
+    #     print(preds)

code/optimization baselines/algorithm/COM.py

@@ -0,0 +1,143 @@
+import numpy as np
+from scipy.optimize import linprog
+
+
+def cargo_load_planning_linear1(weights, cargo_names, cargo_types_dict, positions, cg_impact, cg_impact_2u, cg_impact_4u,
+                        max_positions):
+    """
+    使用整数线性规划方法计算货物装载方案，最小化重心的变化量。
+
+    参数:
+        weights (list): 每个货物的质量列表。
+        cargo_names (list): 每个货物的名称。
+        cargo_types_dict (dict): 货物名称和占用的货位数量。
+        positions (list): 可用的货位编号。
+        cg_impact (list): 每个位置每kg货物对重心index的影响系数。
+        cg_impact_2u (list): 两个位置组合的重心影响系数。
+        cg_impact_4u (list): 四个位置组合的重心影响系数。
+        max_positions (int): 总货位的数量。
+
+    返回:
+        result.x: 最优装载方案矩阵。
+    """
+    # 将货物类型映射为对应的占用单位数
+    cargo_types = [cargo_types_dict[name] for name in cargo_names]
+
+    num_cargos = len(weights)  # 货物数量
+    num_positions = len(positions)  # 可用货位数量
+
+    # 决策变量：xij (是否将货物i放置在位置j)
+    c = []  # 目标函数系数列表
+    for i in range(num_cargos):
+        for j in range(num_positions):
+            if cargo_types[i] == 1:
+                c.append(abs(weights[i] * cg_impact[j]))
+            elif cargo_types[i] == 2 and j % 2 == 0 and j < len(cg_impact_2u) * 2:
+                c.append(abs(weights[i] * cg_impact_2u[j // 2]))
+            elif cargo_types[i] == 4 and j % 4 == 0 and j < len(cg_impact_4u) * 4:
+                c.append(abs(weights[i] * cg_impact_4u[j // 4]))
+            else:
+                c.append(0)  # 不适合的索引默认影响为0
+
+    # 决策变量约束：xij只能是0或1 (整型约束由 linprog 近似处理)
+    bounds = [(0, 1) for _ in range(num_cargos * num_positions)]
+
+    # 约束1：每个货物只能装载到一个位置
+    A_eq = []
+    b_eq = []
+    for i in range(num_cargos):
+        constraint = [0] * (num_cargos * num_positions)
+        for j in range(num_positions):
+            constraint[i * num_positions + j] = 1
+        A_eq.append(constraint)
+        b_eq.append(1)
+
+    # 约束2：每个位置只能装载一个货物
+    A_ub = []
+    b_ub = []
+    for j in range(num_positions):  # 遍历所有位置
+        constraint = [0] * (num_cargos * num_positions)
+        for i in range(num_cargos):  # 遍历所有货物
+            constraint[i * num_positions + j] = 1
+        A_ub.append(constraint)
+        b_ub.append(1)  # 每个位置最多只能分配一个货物
+
+    # 约束3：占用多个位置的货物
+    for i, cargo_type in enumerate(cargo_types):
+        if cargo_type == 2:  # 两个连续位置组合
+            for j in range(0, num_positions - 1, 2):
+                constraint = [0] * (num_cargos * num_positions)
+                constraint[i * num_positions + j] = 1
+                constraint[i * num_positions + j + 1] = 1
+                A_ub.append(constraint)
+                b_ub.append(1)
+        elif cargo_type == 4:  # 上两个、下两个组合
+            for j in range(0, num_positions - 3, 4):
+                constraint = [0] * (num_cargos * num_positions)
+                constraint[i * num_positions + j] = 1
+                constraint[i * num_positions + j + 1] = 1
+                constraint[i * num_positions + j + 2] = 1
+                constraint[i * num_positions + j + 3] = 1
+                A_ub.append(constraint)
+                b_ub.append(1)
+
+    # 转换为numpy数组
+    A_eq = np.array(A_eq)
+    b_eq = np.array(b_eq)
+    A_ub = np.array(A_ub)
+    b_ub = np.array(b_ub)
+    c = np.array(c)
+
+    # 求解线性规划问题
+    result = linprog(c, A_ub=A_ub, b_ub=b_ub, A_eq=A_eq, b_eq=b_eq, bounds=bounds, method='highs')
+
+    if result.success:
+        # print("成功找到最优装载方案！")
+        solution = result.x.reshape((num_cargos, num_positions))
+        # print("装载方案矩阵:")
+        # print(solution)
+
+        # 计算最终重心变化
+        cg_change = 0
+        for i in range(num_cargos):
+            for j in range(num_positions):
+                if cargo_types[i] == 1:
+                    cg_change += solution[i, j] * weights[i] * cg_impact[j]
+                elif cargo_types[i] == 2 and j % 2 == 0 and j < len(cg_impact_2u) * 2:
+                    cg_change += solution[i, j] * weights[i] * cg_impact_2u[j // 2]
+                elif cargo_types[i] == 4 and j % 4 == 0 and j < len(cg_impact_4u) * 4:
+                    cg_change += solution[i, j] * weights[i] * cg_impact_4u[j // 4]
+        # print(f"重心的变化量: {cg_change:.2f}")
+        return result,cg_change
+        # 输出实际分布
+        # print("货物实际分布:")
+        # for i in range(num_cargos):
+        #     assigned_positions = []
+        #     for j in range(num_positions):
+        #         if solution[i, j] > 0.5:  # 判断位置是否被分配
+        #             assigned_positions.append(j)
+        #     print(f"货物 {cargo_names[i]} (占 {cargo_types[i]} 单位): 放置位置 -> {assigned_positions}")
+    else:
+        result = []
+        return result,-1000000
+
+
+
+
+# 示例输入
+# def main():
+#     weights = [500, 800, 1200, 300, 700, 1000, 600, 900]  # 每个货物的质量
+#     cargo_names = ['LD3', 'LD3', 'PLA', 'LD3', 'P6P', 'PLA', 'LD3', 'BULK']  # 货物名称
+#     cargo_types_dict = {"LD3": 1, "PLA": 2, "P6P": 4, "BULK": 1}  # 货物占位关系
+#     positions = list(range(44))  # 44个货位编号
+#     cg_impact = [i * 0.1 for i in range(44)]  # 每kg货物对重心index的影响系数 (单个位置)
+#     cg_impact_2u = [i * 0.08 for i in range(22)]  # 两个位置组合的影响系数
+#     cg_impact_4u = [i * 0.05 for i in range(11)]  # 四个位置组合的影响系数
+#     max_positions = 44  # 总货位数量
+#
+#     result = cargo_load_planning(weights, cargo_names, cargo_types_dict, positions, cg_impact, cg_impact_2u,
+#                                  cg_impact_4u, max_positions)
+#
+#
+# if __name__ == "__main__":
+#     main()

code/optimization baselines/algorithm/DMOPSO.py

@@ -0,0 +1,173 @@
+import numpy as np
+import pyswarms as ps
+
+
+def cargo_load_planning_pso_v2(weights, cargo_names, cargo_types_dict, positions, cg_impact, cg_impact_2u, cg_impact_4u,
+                               max_positions, options=None, swarmsize=100, maxiter=100):
+    """
+    使用二进制粒子群优化方法计算货物装载方案，最小化重心的变化量。
+
+    参数:
+        weights (list): 每个货物的质量列表。
+        cargo_names (list): 每个货物的名称。
+        cargo_types_dict (dict): 货物名称和占用的货位数量。
+        positions (list): 可用的货位编号。
+        cg_impact (list): 每个位置每kg货物对重心index的影响系数。
+        cg_impact_2u (list): 两个位置组合的重心影响系数。
+        cg_impact_4u (list): 四个位置组合的重心影响系数。
+        max_positions (int): 总货位的数量。
+        options (dict, optional): PSO算法的配置选项。
+        swarmsize (int, optional): 粒子群大小。
+        maxiter (int, optional): 最大迭代次数。
+
+    返回:
+        best_solution (np.array): 最优装载方案矩阵。
+        best_cg_change (float): 最优方案的重心变化量。
+    """
+    # 将货物类型映射为对应的占用单位数
+    cargo_types = [cargo_types_dict[name] for name in cargo_names]
+
+    num_cargos = len(weights)  # 货物数量
+    num_positions = len(positions)  # 可用货位数量
+    dimension = num_cargos * max_positions  # 每个粒子的维度：货物数量 × 可用货位数量
+
+    # 如果未提供options，使用默认配置
+    if options is None:
+        options = {'c1': 0.5, 'c2': 0.3, 'w': 0.9}
+
+    # 定义适应度评估函数
+    def fitness_function(x):
+        """
+        计算每个粒子的适应度值。
+
+        参数:
+            x (numpy.ndarray): 粒子的位置数组，形状为 (n_particles, dimension)。
+
+        返回:
+            numpy.ndarray: 每个粒子的适应度值。
+        """
+        fitness = np.zeros(x.shape[0])
+
+        for idx, particle in enumerate(x):
+            # 将连续位置映射为离散起始位置
+            start_positions = []
+            penalty = 0
+            cg_change = 0.0
+            occupied = np.zeros(num_positions, dtype=int)
+
+            for i in range(num_cargos):
+                cargo_type = cargo_types[i]
+                pos_continuous = particle[i * max_positions:(i + 1) * max_positions]
+
+                # 根据粒子位置值选择最佳货位
+                start_pos = np.argmax(pos_continuous)
+
+                # 检查边界
+                if start_pos < 0 or start_pos + cargo_type > num_positions:
+                    penalty += 1000
+                    continue
+
+                # 检查对齐
+                if cargo_type == 2 and start_pos % 2 != 0:
+                    penalty += 1000
+                if cargo_type == 4 and start_pos % 4 != 0:
+                    penalty += 1000
+
+                # 检查重叠
+                if np.any(occupied[start_pos:start_pos + cargo_type]):
+                    penalty += 1000
+                else:
+                    occupied[start_pos:start_pos + cargo_type] = 1
+
+                start_positions.append(start_pos)
+
+                # 计算重心变化量
+                if cargo_type == 1:
+                    cg_change += weights[i] * cg_impact[start_pos]
+                elif cargo_type == 2:
+                    cg_change += weights[i] * cg_impact_2u[start_pos // 2]
+                elif cargo_type == 4:
+                    cg_change += weights[i] * cg_impact_4u[start_pos // 4]
+
+            fitness[idx] = cg_change + penalty
+
+        return fitness
+
+    # 设置PSO的边界
+    # 对于每个货物，起始位置的范围根据货物类型对齐
+    lower_bounds = []
+    upper_bounds = []
+    for i in range(num_cargos):
+        cargo_type = cargo_types[i]
+        lower_bounds.append([0] * max_positions)
+        upper_bounds.append([1] * max_positions)
+
+    bounds = (np.array(lower_bounds), np.array(upper_bounds))
+
+    # 初始化PSO优化器
+    optimizer = ps.single.GlobalBestPSO(n_particles=swarmsize, dimensions=dimension, options=options, bounds=bounds)
+
+    # 运行PSO优化
+    best_cost, best_pos = optimizer.optimize(fitness_function, iters=maxiter)
+
+    # 将最佳位置映射为离散装载方案
+    best_start_positions = []
+    penalty = 0
+    cg_change = 0.0
+    occupied = np.zeros(num_positions, dtype=int)
+
+    for i in range(num_cargos):
+        cargo_type = cargo_types[i]
+        pos_continuous = best_pos[i * max_positions:(i + 1) * max_positions]
+
+        # 根据粒子位置值选择最佳货位
+        start_pos = np.argmax(pos_continuous)
+
+        # 检查边界
+        if start_pos < 0 or start_pos + cargo_type > num_positions:
+            penalty += 1000
+            best_start_positions.append(start_pos)
+            continue
+
+        # 检查对齐
+        if cargo_type == 2 and start_pos % 2 != 0:
+            penalty += 1000
+        if cargo_type == 4 and start_pos % 4 != 0:
+            penalty += 1000
+
+        # 检查重叠
+        if np.any(occupied[start_pos:start_pos + cargo_type]):
+            penalty += 1000
+        else:
+            occupied[start_pos:start_pos + cargo_type] = 1
+
+        best_start_positions.append(start_pos)
+
+        # 计算重心变化量
+        if cargo_type == 1:
+            cg_change += abs(weights[i] * cg_impact[start_pos])
+        elif cargo_type == 2:
+            cg_change += abs(weights[i] * cg_impact_2u[start_pos // 2])
+        elif cargo_type == 4:
+            cg_change += abs(weights[i] * cg_impact_4u[start_pos // 4])
+
+    total_cg_change = cg_change + penalty
+
+    # 构建装载方案矩阵
+    best_xij = np.zeros((num_cargos, num_positions), dtype=int)
+    for i, start_pos in enumerate(best_start_positions):
+        cargo_type = cargo_types[i]
+        for k in range(cargo_type):
+            pos = start_pos + k
+            if pos < num_positions:
+                best_xij[i, pos] = 1
+
+    # 检查是否有严重惩罚，判断是否找到可行解
+    if total_cg_change >= -999999:
+        return best_xij, total_cg_change
+    else:
+        return [], -1000000
+
+
+# 示例调用
+

code/optimization baselines/algorithm/GA-normal.py

@@ -0,0 +1,238 @@
+import numpy as np
+import random
+from deap import base, creator, tools, algorithms
+
+
+def cargo_load_planning_genetic(weights, cargo_names, cargo_types_dict, positions, cg_impact, cg_impact_2u, cg_impact_4u,
+                                max_positions, population_size=100, generations=100, crossover_prob=0.7, mutation_prob=0.2):
+    """
+    使用遗传算法计算货物装载方案，最小化重心的变化量。
+
+    参数:
+        weights (list): 每个货物的质量列表。
+        cargo_names (list): 每个货物的名称。
+        cargo_types_dict (dict): 货物名称和占用的货位数量。
+        positions (list): 可用的货位编号。
+        cg_impact (list): 每个位置每kg货物对重心index的影响系数。
+        cg_impact_2u (list): 两个位置组合的重心影响系数。
+        cg_impact_4u (list): 四个位置组合的重心影响系数。
+        max_positions (int): 总货位的数量。
+        population_size (int): 遗传算法的种群大小。
+        generations (int): 遗传算法的代数。
+        crossover_prob (float): 交叉操作的概率。
+        mutation_prob (float): 变异操作的概率。
+
+    返回:
+        best_solution (np.array): 最优装载方案矩阵。
+        best_cg_change (float): 最优方案的重心变化量。
+    """
+    try:
+        # 将货物类型映射为对应的占用单位数
+        cargo_types = [cargo_types_dict[name] for name in cargo_names]
+
+        num_cargos = len(weights)       # 货物数量
+        num_positions = len(positions)  # 可用货位数量
+
+        # 定义适应度函数（最小化重心变化量）
+        if not hasattr(creator, "FitnessMin"):
+            creator.create("FitnessMin", base.Fitness, weights=(-1.0,))
+        if not hasattr(creator, "Individual"):
+            creator.create("Individual", list, fitness=creator.FitnessMin)
+
+        toolbox = base.Toolbox()
+
+        # 个体初始化函数，确保货物类型为2和4时起始位置对齐
+        def init_individual():
+            individual = []
+            occupied = [False] * num_positions
+            for cargo_type in cargo_types:
+                if cargo_type == 1:
+                    valid_positions = [j for j in range(num_positions) if not occupied[j]]
+                elif cargo_type == 2:
+                    valid_positions = [j for j in range(0, num_positions - 1, 2) if not any(occupied[j + k] for k in range(cargo_type))]
+                elif cargo_type == 4:
+                    valid_positions = [j for j in range(0, num_positions - 3, 4) if not any(occupied[j + k] for k in range(cargo_type))]
+                else:
+                    valid_positions = []
+
+                if not valid_positions:
+                    # 如果没有有效位置，随机选择一个符合类型对齐的起始位置
+                    if cargo_type == 1:
+                        start_pos = random.randint(0, num_positions - 1)
+                    elif cargo_type == 2:
+                        choices = [j for j in range(0, num_positions - 1, 2)]
+                        if choices:
+                            start_pos = random.choice(choices)
+                        else:
+                            start_pos = 0  # 默认位置
+                    elif cargo_type == 4:
+                        choices = [j for j in range(0, num_positions - 3, 4)]
+                        if choices:
+                            start_pos = random.choice(choices)
+                        else:
+                            start_pos = 0  # 默认位置
+                    else:
+                        start_pos = 0  # 默认位置
+                else:
+                    start_pos = random.choice(valid_positions)
+
+                individual.append(start_pos)
+
+                # 标记占用的位置
+                for k in range(cargo_type):
+                    pos = start_pos + k
+                    if pos < num_positions:
+                        occupied[pos] = True
+
+            return creator.Individual(individual)
+
+        toolbox.register("individual", init_individual)
+        toolbox.register("population", tools.initRepeat, list, toolbox.individual)
+
+        # 适应度评估函数
+        def evaluate(individual):
+            # 检查重叠和边界
+            occupied = [False] * num_positions
+            penalty = 0
+            cg_change = 0.0
+
+            for i, start_pos in enumerate(individual):
+                cargo_type = cargo_types[i]
+                weight = weights[i]
+
+                # 检查边界
+                if start_pos < 0 or start_pos + cargo_type > num_positions:
+                    penalty += 10000 # 超出边界的严重惩罚
+                    continue
+
+                # 检查重叠
+                overlap = False
+                for k in range(cargo_type):
+                    pos = start_pos + k
+                    if occupied[pos]:
+                        penalty += 10000  # 重叠的严重惩罚
+                        overlap = True
+                        break
+                    occupied[pos] = True
+                if overlap:
+                    continue
+
+                # 计算重心变化量
+                if cargo_type == 1:
+                    cg_change += abs(weight * cg_impact[start_pos])
+                elif cargo_type == 2:
+                    if start_pos % 2 == 0 and (start_pos // 2) < len(cg_impact_2u):
+                        cg_change += abs(weight * cg_impact_2u[start_pos // 2])
+                    else:
+                        penalty += 10000  # 不对齐的严重惩罚
+                elif cargo_type == 4:
+                    if start_pos % 4 == 0 and (start_pos // 4) < len(cg_impact_4u):
+                        cg_change += abs(weight * cg_impact_4u[start_pos // 4])
+                    else:
+                        penalty += 10000  # 不对齐的严重惩罚
+
+            return (cg_change + penalty,)
+
+        toolbox.register("evaluate", evaluate)
+        toolbox.register("mate", tools.cxTwoPoint)
+
+        # 自定义变异函数，确保变异后的起始位置对齐
+        def custom_mutate(individual, indpb):
+            for i in range(len(individual)):
+                if random.random() < indpb:
+                    cargo_type = cargo_types[i]
+                    try:
+                        if cargo_type == 1:
+                            new_pos = random.randint(0, num_positions - 1)
+                        elif cargo_type == 2:
+                            choices = [j for j in range(0, num_positions - 1, 2)]
+                            if choices:
+                                new_pos = random.choice(choices)
+                            else:
+                                new_pos = individual[i]  # 如果没有可选位置，保持不变
+                        elif cargo_type == 4:
+                            choices = [j for j in range(0, num_positions - 3, 4)]
+                            if choices:
+                                new_pos = random.choice(choices)
+                            else:
+                                new_pos = individual[i]  # 如果没有可选位置，保持不变
+                        else:
+                            new_pos = individual[i]  # 保持不变
+                        individual[i] = new_pos
+                    except ValueError:
+                        # 捕获可能的 ValueError 并直接返回当前个体
+                        return individual,
+            return (individual,)
+
+        toolbox.register("mutate", custom_mutate, indpb=mutation_prob)
+        toolbox.register("select", tools.selTournament, tournsize=3)
+
+        # 初始化种群
+        population = toolbox.population(n=population_size)
+
+        # 运行遗传算法
+        try:
+            algorithms.eaSimple(population, toolbox, cxpb=crossover_prob, mutpb=1.0, ngen=generations,
+                                verbose=False)
+        except ValueError as e:
+            print(f"遗传算法运行时出错: {e}")
+            return [], -1000000  # 返回空列表和一个负的重心变化量作为错误标志
+
+        # 选择最优个体
+        try:
+            best_individual = tools.selBest(population, 1)[0]
+            best_cg_change = evaluate(best_individual)[0]
+        except IndexError as e:
+            print(f"选择最优个体时出错: {e}")
+            return [], -1000000  # 返回空列表和一个负的重心变化量作为错误标志
+
+        # 构建装载方案矩阵
+        solution = np.zeros((num_cargos, num_positions))
+        for i, start_pos in enumerate(best_individual):
+            cargo_type = cargo_types[i]
+            for k in range(cargo_type):
+                pos = start_pos + k
+                if pos < num_positions:
+                    solution[i, pos] = 1
+
+        return solution, best_cg_change
+    except:
+        return [],-1000000
+
+
+# # 示例输入和调用
+# def main():
+#     weights = [500, 800, 1200, 300, 700, 1000, 600, 900]  # 每个货物的质量
+#     cargo_names = ['LD3', 'LD3', 'PLA', 'LD3', 'P6P', 'PLA', 'LD3', 'BULK']  # 货物名称
+#     cargo_types_dict = {"LD3": 1, "PLA": 2, "P6P": 4, "BULK": 1}  # 货物占位关系
+#     positions = list(range(44))  # 44个货位编号
+#     cg_impact = [i * 0.1 for i in range(44)]  # 每kg货物对重心index的影响系数 (单个位置)
+#     cg_impact_2u = [i * 0.08 for i in range(22)]  # 两个位置组合的影响系数
+#     cg_impact_4u = [i * 0.05 for i in range(11)]  # 四个位置组合的影响系数
+#     max_positions = 44  # 总货位数量
+#
+#     solution, cg_change = cargo_load_planning_genetic(
+#         weights, cargo_names, cargo_types_dict, positions,
+#         cg_impact, cg_impact_2u, cg_impact_4u, max_positions,
+#         population_size=200, generations=200, crossover_prob=0.8, mutation_prob=0.2
+#     )
+#
+#     if solution is not None and len(solution) > 0:
+#         print("成功找到最优装载方案！")
+#         print("装载方案矩阵:")
+#         print(solution)
+#         print(f"重心的变化量: {cg_change:.2f}")
+
+        # 输出实际分布
+#         for i in range(len(weights)):
+#             assigned_positions = []
+#             for j in range(len(positions)):
+#                 if solution[i, j] > 0.5:  # 判断位置是否被分配
+#                     assigned_positions.append(j)
+#             print(f"货物 {cargo_names[i]} (占 {cargo_types_dict[cargo_names[i]]} 单位): 放置位置 -> {assigned_positions}")
+#     else:
+#         print("未找到可行的装载方案。")
+#
+#
+# if __name__ == "__main__":
+#     main()

code/optimization baselines/algorithm/HGA.py

@@ -0,0 +1,178 @@
+import numpy as np
+import random
+from deap import base, creator, tools, algorithms
+
+
+def cargo_load_planning_genetic(weights, cargo_names, cargo_types_dict, positions, cg_impact, cg_impact_2u, cg_impact_4u,
+                                max_positions, population_size=100, generations=100, crossover_prob=0.7, mutation_prob=0.2):
+    """
+    使用改进版遗传算法计算货物装载方案，最小化重心的变化量。
+
+    参数:
+        weights (list): 每个货物的质量列表。
+        cargo_names (list): 每个货物的名称。
+        cargo_types_dict (dict): 货物名称和占用的货位数量。
+        positions (list): 可用的货位编号。
+        cg_impact (list): 每个位置每kg货物对重心index的影响系数。
+        cg_impact_2u (list): 两个位置组合的重心影响系数。
+        cg_impact_4u (list): 四个位置组合的重心影响系数。
+        max_positions (int): 总货位的数量。
+        population_size (int): 遗传算法的种群大小。
+        generations (int): 遗传算法的代数。
+        crossover_prob (float): 交叉操作的概率。
+        mutation_prob (float): 变异操作的概率。
+
+    返回:
+        best_solution (np.array): 最优装载方案矩阵。
+        best_cg_change (float): 最优方案的重心变化量。
+    """
+    try:
+        # 将货物类型映射为对应的占用单位数
+        cargo_types = [cargo_types_dict[name] for name in cargo_names]
+
+        num_cargos = len(weights)       # 货物数量
+        num_positions = len(positions)  # 可用货位数量
+
+        # 定义适应度函数（最小化重心变化量）
+        if not hasattr(creator, "FitnessMin"):
+            creator.create("FitnessMin", base.Fitness, weights=(-1.0,))  # 目标是最小化
+        if not hasattr(creator, "Individual"):
+            creator.create("Individual", list, fitness=creator.FitnessMin)
+
+        toolbox = base.Toolbox()
+
+        # 个体初始化函数
+        def init_individual():
+            individual = []
+            occupied = [False] * num_positions
+            for cargo_type in cargo_types:
+                if cargo_type == 1:
+                    valid_positions = [j for j in range(num_positions) if not occupied[j]]
+                elif cargo_type == 2:
+                    valid_positions = [j for j in range(0, num_positions - 1, 2) if not any(occupied[j + k] for k in range(cargo_type))]
+                elif cargo_type == 4:
+                    valid_positions = [j for j in range(0, num_positions - 3, 4) if not any(occupied[j + k] for k in range(cargo_type))]
+                else:
+                    valid_positions = []
+
+                if not valid_positions:
+                    # 如果没有有效位置，随机选择一个符合类型对齐的起始位置
+                    if cargo_type == 1:
+                        start_pos = random.randint(0, num_positions - 1)
+                    elif cargo_type == 2:
+                        choices = [j for j in range(0, num_positions - 1, 2)]
+                        if choices:
+                            start_pos = random.choice(choices)
+                        else:
+                            start_pos = 0  # 默认位置
+                    elif cargo_type == 4:
+                        choices = [j for j in range(0, num_positions - 3, 4)]
+                        if choices:
+                            start_pos = random.choice(choices)
+                        else:
+                            start_pos = 0  # 默认位置
+                    else:
+                        start_pos = 0  # 默认位置
+                else:
+                    start_pos = random.choice(valid_positions)
+
+                individual.append(start_pos)
+
+                # 标记占用的位置
+                for k in range(cargo_type):
+                    pos = start_pos + k
+                    if pos < num_positions:
+                        occupied[pos] = True
+
+            return creator.Individual(individual)
+
+        toolbox.register("individual", init_individual)
+        toolbox.register("population", tools.initRepeat, list, toolbox.individual)
+
+        # 适应度评估函数
+        def evaluate(individual):
+            # 检查重叠和边界
+            occupied = [False] * num_positions
+            penalty = 0
+            cg_change = 0.0
+
+            for i, start_pos in enumerate(individual):
+                cargo_type = cargo_types[i]
+                weight = weights[i]
+
+                # 检查边界
+                if start_pos < 0 or start_pos + cargo_type > num_positions:
+                    penalty += 10000 # 超出边界的严重惩罚
+                    continue
+
+                # 检查重叠
+                overlap = False
+                for k in range(cargo_type):
+                    pos = start_pos + k
+                    if occupied[pos]:
+                        penalty += 10000  # 重叠的严重惩罚
+                        overlap = True
+                        break
+                    occupied[pos] = True
+                if overlap:
+                    continue
+
+                # 计算重心变化量
+                if cargo_type == 1:
+                    cg_change += abs(weight * cg_impact[start_pos])
+                elif cargo_type == 2:
+                    if start_pos % 2 == 0 and (start_pos // 2) < len(cg_impact_2u):
+                        cg_change += abs(weight * cg_impact_2u[start_pos // 2])
+                    else:
+                        penalty += 10000  # 不对齐的严重惩罚
+                elif cargo_type == 4:
+                    if start_pos % 4 == 0 and (start_pos // 4) < len(cg_impact_4u):
+                        cg_change += abs(weight * cg_impact_4u[start_pos // 4])
+                    else:
+                        penalty += 10000  # 不对齐的严重惩罚
+
+            return (cg_change + penalty,)
+
+        toolbox.register("evaluate", evaluate)
+        toolbox.register("mate", tools.cxOnePoint)  # 改为单点交叉
+        toolbox.register("mutate", tools.mutShuffleIndexes, indpb=mutation_prob)  # 使用交换变异
+        toolbox.register("select", tools.selRoulette)  # 轮盘赌选择
+
+        # 初始化种群
+        population = toolbox.population(n=population_size)
+
+        # 运行遗传算法
+        try:
+            algorithms.eaSimple(population, toolbox, cxpb=crossover_prob, mutpb=1.0, ngen=generations,
+                                verbose=False)
+        except ValueError as e:
+            print(f"遗传算法运行时出错: {e}")
+            return [], -1000000  # 返回空列表和一个负的重心变化量作为错误标志
+
+        # 选择最优个体
+        try:
+            best_individual = tools.selBest(population, 1)[0]
+            best_cg_change = evaluate(best_individual)[0]
+        except IndexError as e:
+            print(f"选择最优个体时出错: {e}")
+            return [], -1000000  # 返回空列表和一个负的重心变化量作为错误标志
+
+        # 构建装载方案矩阵
+        solution = np.zeros((num_cargos, num_positions))
+        for i, start_pos in enumerate(best_individual):
+            cargo_type = cargo_types[i]
+            for k in range(cargo_type):
+                pos = start_pos + k
+                if pos < num_positions:
+                    solution[i, pos] = 1
+
+        return solution, best_cg_change
+    except Exception as e:
+        print(f"发生错误: {e}")
+        return [], -1000000
+
+#
+# # 示例输入和调用
+# def main():
+#     weights = [500, 800, 1200, 300, 700, 1000, 600, 900]  # 每个货物的质量
+#     cargo_names = ['LD3', 'LD3

code/optimization baselines/algorithm/IOM.py

@@ -0,0 +1,143 @@
+import numpy as np
+from scipy.optimize import linprog
+
+
+def cargo_load_planning_linear2(weights, cargo_names, cargo_types_dict, positions, cg_impact, cg_impact_2u, cg_impact_4u,
+                        max_positions):
+    """
+    使用整数线性规划方法计算货物装载方案，最小化重心的变化量。
+
+    参数:
+        weights (list): 每个货物的质量列表。
+        cargo_names (list): 每个货物的名称。
+        cargo_types_dict (dict): 货物名称和占用的货位数量。
+        positions (list): 可用的货位编号。
+        cg_impact (list): 每个位置每kg货物对重心index的影响系数。
+        cg_impact_2u (list): 两个位置组合的重心影响系数。
+        cg_impact_4u (list): 四个位置组合的重心影响系数。
+        max_positions (int): 总货位的数量。
+
+    返回:
+        result.x: 最优装载方案矩阵。
+    """
+    # 将货物类型映射为对应的占用单位数
+    cargo_types = [cargo_types_dict[name] for name in cargo_names]
+
+    num_cargos = len(weights)  # 货物数量
+    num_positions = len(positions)  # 可用货位数量
+
+    # 决策变量：xij (是否将货物i放置在位置j)
+    c = []  # 目标函数系数列表
+    for i in range(num_cargos):
+        for j in range(num_positions):
+            if cargo_types[i] == 1:
+                c.append(abs(weights[i] * cg_impact[j]))
+            elif cargo_types[i] == 2 and j % 2 == 0 and j < len(cg_impact_2u) * 2:
+                c.append(abs(weights[i] * cg_impact_2u[j // 2]))
+            elif cargo_types[i] == 4 and j % 4 == 0 and j < len(cg_impact_4u) * 4:
+                c.append(abs(weights[i] * cg_impact_4u[j // 4]))
+            else:
+                c.append(0)  # 不适合的索引默认影响为0
+
+    # 决策变量约束：xij只能是0或1 (整型约束由 linprog 近似处理)
+    bounds = [(0, 1) for _ in range(num_cargos * num_positions)]
+
+    # 约束1：每个货物只能装载到一个位置
+    A_eq = []
+    b_eq = []
+    for i in range(num_cargos):
+        constraint = [0] * (num_cargos * num_positions)
+        for j in range(num_positions):
+            constraint[i * num_positions + j] = 1
+        A_eq.append(constraint)
+        b_eq.append(1)
+
+    # 约束2：每个位置只能装载一个货物
+    A_ub = []
+    b_ub = []
+    for j in range(num_positions):  # 遍历所有位置
+        constraint = [0] * (num_cargos * num_positions)
+        for i in range(num_cargos):  # 遍历所有货物
+            constraint[i * num_positions + j] = 1
+        A_ub.append(constraint)
+        b_ub.append(1)  # 每个位置最多只能分配一个货物
+
+    # 约束3：占用多个位置的货物
+    for i, cargo_type in enumerate(cargo_types):
+        if cargo_type == 2:  # 两个连续位置组合
+            for j in range(0, num_positions - 1, 2):
+                constraint = [0] * (num_cargos * num_positions)
+                constraint[i * num_positions + j] = 1
+                constraint[i * num_positions + j + 1] = 1
+                A_ub.append(constraint)
+                b_ub.append(1)
+        elif cargo_type == 4:  # 上两个、下两个组合
+            for j in range(0, num_positions - 3, 4):
+                constraint = [0] * (num_cargos * num_positions)
+                constraint[i * num_positions + j] = 1
+                constraint[i * num_positions + j + 1] = 1
+                constraint[i * num_positions + j + 2] = 1
+                constraint[i * num_positions + j + 3] = 1
+                A_ub.append(constraint)
+                b_ub.append(1)
+
+    # 转换为numpy数组
+    A_eq = np.array(A_eq)
+    b_eq = np.array(b_eq)
+    A_ub = np.array(A_ub)
+    b_ub = np.array(b_ub)
+    c = np.array(c)
+
+    # 求解线性规划问题
+    result = linprog(c, A_ub=A_ub, b_ub=b_ub, A_eq=A_eq, b_eq=b_eq, bounds=bounds, method='highs-ds')
+
+    if result.success:
+        # print("成功找到最优装载方案！")
+        solution = result.x.reshape((num_cargos, num_positions))
+        # print("装载方案矩阵:")
+        # print(solution)
+
+        # 计算最终重心变化
+        cg_change = 0
+        for i in range(num_cargos):
+            for j in range(num_positions):
+                if cargo_types[i] == 1:
+                    cg_change += solution[i, j] * weights[i] * cg_impact[j]
+                elif cargo_types[i] == 2 and j % 2 == 0 and j < len(cg_impact_2u) * 2:
+                    cg_change += solution[i, j] * weights[i] * cg_impact_2u[j // 2]
+                elif cargo_types[i] == 4 and j % 4 == 0 and j < len(cg_impact_4u) * 4:
+                    cg_change += solution[i, j] * weights[i] * cg_impact_4u[j // 4]
+        # print(f"重心的变化量: {cg_change:.2f}")
+        return result,cg_change
+        # 输出实际分布
+        # print("货物实际分布:")
+        # for i in range(num_cargos):
+        #     assigned_positions = []
+        #     for j in range(num_positions):
+        #         if solution[i, j] > 0.5:  # 判断位置是否被分配
+        #             assigned_positions.append(j)
+        #     print(f"货物 {cargo_names[i]} (占 {cargo_types[i]} 单位): 放置位置 -> {assigned_positions}")
+    else:
+        result = []
+        return result,-1000000
+
+
+
+
+# 示例输入
+# def main():
+#     weights = [500, 800, 1200, 300, 700, 1000, 600, 900]  # 每个货物的质量
+#     cargo_names = ['LD3', 'LD3', 'PLA', 'LD3', 'P6P', 'PLA', 'LD3', 'BULK']  # 货物名称
+#     cargo_types_dict = {"LD3": 1, "PLA": 2, "P6P": 4, "BULK": 1}  # 货物占位关系
+#     positions = list(range(44))  # 44个货位编号
+#     cg_impact = [i * 0.1 for i in range(44)]  # 每kg货物对重心index的影响系数 (单个位置)
+#     cg_impact_2u = [i * 0.08 for i in range(22)]  # 两个位置组合的影响系数
+#     cg_impact_4u = [i * 0.05 for i in range(11)]  # 四个位置组合的影响系数
+#     max_positions = 44  # 总货位数量
+#
+#     result = cargo_load_planning(weights, cargo_names, cargo_types_dict, positions, cg_impact, cg_impact_2u,
+#                                  cg_impact_4u, max_positions)
+#
+#
+# if __name__ == "__main__":
+#     main()

code/optimization baselines/algorithm/MLIP-ACLPDD.py

@@ -0,0 +1,143 @@
+import numpy as np
+from scipy.optimize import linprog
+
+
+def cargo_load_planning_linear3(weights, cargo_names, cargo_types_dict, positions, cg_impact, cg_impact_2u, cg_impact_4u,
+                        max_positions):
+    """
+    使用整数线性规划方法计算货物装载方案，最小化重心的变化量。
+
+    参数:
+        weights (list): 每个货物的质量列表。
+        cargo_names (list): 每个货物的名称。
+        cargo_types_dict (dict): 货物名称和占用的货位数量。
+        positions (list): 可用的货位编号。
+        cg_impact (list): 每个位置每kg货物对重心index的影响系数。
+        cg_impact_2u (list): 两个位置组合的重心影响系数。
+        cg_impact_4u (list): 四个位置组合的重心影响系数。
+        max_positions (int): 总货位的数量。
+
+    返回:
+        result.x: 最优装载方案矩阵。
+    """
+    # 将货物类型映射为对应的占用单位数
+    cargo_types = [cargo_types_dict[name] for name in cargo_names]
+
+    num_cargos = len(weights)  # 货物数量
+    num_positions = len(positions)  # 可用货位数量
+
+    # 决策变量：xij (是否将货物i放置在位置j)
+    c = []  # 目标函数系数列表
+    for i in range(num_cargos):
+        for j in range(num_positions):
+            if cargo_types[i] == 1:
+                c.append(abs(weights[i] * cg_impact[j]))
+            elif cargo_types[i] == 2 and j % 2 == 0 and j < len(cg_impact_2u) * 2:
+                c.append(abs(weights[i] * cg_impact_2u[j // 2]))
+            elif cargo_types[i] == 4 and j % 4 == 0 and j < len(cg_impact_4u) * 4:
+                c.append(abs(weights[i] * cg_impact_4u[j // 4]))
+            else:
+                c.append(0)  # 不适合的索引默认影响为0
+
+    # 决策变量约束：xij只能是0或1 (整型约束由 linprog 近似处理)
+    bounds = [(0, 1) for _ in range(num_cargos * num_positions)]
+
+    # 约束1：每个货物只能装载到一个位置
+    A_eq = []
+    b_eq = []
+    for i in range(num_cargos):
+        constraint = [0] * (num_cargos * num_positions)
+        for j in range(num_positions):
+            constraint[i * num_positions + j] = 1
+        A_eq.append(constraint)
+        b_eq.append(1)
+
+    # 约束2：每个位置只能装载一个货物
+    A_ub = []
+    b_ub = []
+    for j in range(num_positions):  # 遍历所有位置
+        constraint = [0] * (num_cargos * num_positions)
+        for i in range(num_cargos):  # 遍历所有货物
+            constraint[i * num_positions + j] = 1
+        A_ub.append(constraint)
+        b_ub.append(1)  # 每个位置最多只能分配一个货物
+
+    # 约束3：占用多个位置的货物
+    for i, cargo_type in enumerate(cargo_types):
+        if cargo_type == 2:  # 两个连续位置组合
+            for j in range(0, num_positions - 1, 2):
+                constraint = [0] * (num_cargos * num_positions)
+                constraint[i * num_positions + j] = 1
+                constraint[i * num_positions + j + 1] = 1
+                A_ub.append(constraint)
+                b_ub.append(1)
+        elif cargo_type == 4:  # 上两个、下两个组合
+            for j in range(0, num_positions - 3, 4):
+                constraint = [0] * (num_cargos * num_positions)
+                constraint[i * num_positions + j] = 1
+                constraint[i * num_positions + j + 1] = 1
+                constraint[i * num_positions + j + 2] = 1
+                constraint[i * num_positions + j + 3] = 1
+                A_ub.append(constraint)
+                b_ub.append(1)
+
+    # 转换为numpy数组
+    A_eq = np.array(A_eq)
+    b_eq = np.array(b_eq)
+    A_ub = np.array(A_ub)
+    b_ub = np.array(b_ub)
+    c = np.array(c)
+
+    # 求解线性规划问题
+    result = linprog(c, A_ub=A_ub, b_ub=b_ub, A_eq=A_eq, b_eq=b_eq, bounds=bounds, method='highs-ipm')
+
+    if result.success:
+        # print("成功找到最优装载方案！")
+        solution = result.x.reshape((num_cargos, num_positions))
+        # print("装载方案矩阵:")
+        # print(solution)
+
+        # 计算最终重心变化
+        cg_change = 0
+        for i in range(num_cargos):
+            for j in range(num_positions):
+                if cargo_types[i] == 1:
+                    cg_change += solution[i, j] * weights[i] * cg_impact[j]
+                elif cargo_types[i] == 2 and j % 2 == 0 and j < len(cg_impact_2u) * 2:
+                    cg_change += solution[i, j] * weights[i] * cg_impact_2u[j // 2]
+                elif cargo_types[i] == 4 and j % 4 == 0 and j < len(cg_impact_4u) * 4:
+                    cg_change += solution[i, j] * weights[i] * cg_impact_4u[j // 4]
+        # print(f"重心的变化量: {cg_change:.2f}")
+        return result,cg_change
+        # 输出实际分布
+        # print("货物实际分布:")
+        # for i in range(num_cargos):
+        #     assigned_positions = []
+        #     for j in range(num_positions):
+        #         if solution[i, j] > 0.5:  # 判断位置是否被分配
+        #             assigned_positions.append(j)
+        #     print(f"货物 {cargo_names[i]} (占 {cargo_types[i]} 单位): 放置位置 -> {assigned_positions}")
+    else:
+        result = []
+        return result,-1000000
+
+
+
+
+# 示例输入
+# def main():
+#     weights = [500, 800, 1200, 300, 700, 1000, 600, 900]  # 每个货物的质量
+#     cargo_names = ['LD3', 'LD3', 'PLA', 'LD3', 'P6P', 'PLA', 'LD3', 'BULK']  # 货物名称
+#     cargo_types_dict = {"LD3": 1, "PLA": 2, "P6P": 4, "BULK": 1}  # 货物占位关系
+#     positions = list(range(44))  # 44个货位编号
+#     cg_impact = [i * 0.1 for i in range(44)]  # 每kg货物对重心index的影响系数 (单个位置)
+#     cg_impact_2u = [i * 0.08 for i in range(22)]  # 两个位置组合的影响系数
+#     cg_impact_4u = [i * 0.05 for i in range(11)]  # 四个位置组合的影响系数
+#     max_positions = 44  # 总货位数量
+#
+#     result = cargo_load_planning(weights, cargo_names, cargo_types_dict, positions, cg_impact, cg_impact_2u,
+#                                  cg_impact_4u, max_positions)
+#
+#
+# if __name__ == "__main__":
+#     main()

code/optimization baselines/algorithm/MLIP-WBP.py

@@ -0,0 +1,137 @@
+import numpy as np
+import pulp
+
+def cargo_load_planning_mip1(weights, cargo_names, cargo_types_dict, positions, cg_impact, cg_impact_2u, cg_impact_4u,
+                            max_positions):
+    """
+    使用混合整数规划方法计算货物装载方案，最小化重心的变化量。
+
+    参数:
+        weights (list): 每个货物的质量列表。
+        cargo_names (list): 每个货物的名称。
+        cargo_types_dict (dict): 货物名称和占用的货位数量。
+        positions (list): 可用的货位编号。
+        cg_impact (list): 每个位置每kg货物对重心index的影响系数。
+        cg_impact_2u (list): 两个位置组合的重心影响系数。
+        cg_impact_4u (list): 四个位置组合的重心影响系数。
+        max_positions (int): 总货位的数量。
+
+    返回:
+        result (pulp.LpStatus): 求解状态。
+        cg_change (float): 最优解的重心变化量。
+        solution_matrix (np.ndarray): 最优装载方案矩阵。
+    """
+    # 将货物类型映射为对应的占用单位数
+    cargo_types = [cargo_types_dict[name] for name in cargo_names]
+
+    num_cargos = len(weights)        # 货物数量
+    num_positions = len(positions)   # 可用货位数量
+
+    # 创建优化问题实例
+    prob = pulp.LpProblem("Cargo_Load_Planning", pulp.LpMinimize)
+
+    # 创建决策变量 x_ij (是否将货物i放置在位置j)
+    # 使用字典键 (i,j) 来标识变量
+    x = pulp.LpVariable.dicts("x",
+                              ((i, j) for i in range(num_cargos) for j in range(num_positions)),
+                              cat='Binary')
+
+    # 定义目标函数：最小化重心的变化量
+    objective_terms = []
+    for i in range(num_cargos):
+        for j in range(num_positions):
+            if cargo_types[i] == 1:
+                impact = abs(weights[i] * cg_impact[j])
+            elif cargo_types[i] == 2 and j % 2 == 0 and j < len(cg_impact_2u) * 2:
+                impact = abs(weights[i] * cg_impact_2u[j // 2])
+            elif cargo_types[i] == 4 and j % 4 == 0 and j < len(cg_impact_4u) * 4:
+                impact = abs(weights[i] * cg_impact_4u[j // 4])
+            else:
+                impact = 0
+            objective_terms.append(impact * x[i, j])
+
+    prob += pulp.lpSum(objective_terms), "Total_CG_Change"
+
+    # 约束1：每个货物只能装载到一个位置
+    for i in range(num_cargos):
+        prob += pulp.lpSum([x[i, j] for j in range(num_positions)]) == 1, f"Cargo_{i}_Single_Position"
+
+    # 约束2：每个位置只能装载一个货物
+    for j in range(num_positions):
+        prob += pulp.lpSum([x[i, j] for i in range(num_cargos)]) <= 1, f"Position_{j}_Single_Cargo"
+
+    # 约束3：占用多个位置的货物
+    for i, cargo_type in enumerate(cargo_types):
+        if cargo_type == 2:  # 两个连续位置组合
+            for j in range(0, num_positions - 1, 2):
+                prob += x[i, j] + x[i, j + 1] <= 1, f"Cargo_{i}_Type2_Position_{j}_{j+1}"
+        elif cargo_type == 4:  # 四个连续位置组合
+            for j in range(0, num_positions - 3, 4):
+                prob += x[i, j] + x[i, j + 1] + x[i, j + 2] + x[i, j + 3] <= 1, f"Cargo_{i}_Type4_Position_{j}_{j+3}"
+
+    # 求解问题
+    solver = pulp.GLPK_CMD(msg=False)  # 使用默认的CBC求解器，不显示求解过程
+    prob.solve(solver)
+
+    # 检查求解状态
+    if pulp.LpStatus[prob.status] == 'Optimal':
+        # 构建装载方案矩阵
+        solution = np.zeros((num_cargos, num_positions))
+        for i in range(num_cargos):
+            for j in range(num_positions):
+                var_value = pulp.value(x[i, j])
+                if var_value is not None and var_value > 0.5:
+                    solution[i, j] = 1
+
+        # 计算最终重心变化
+        cg_change = 0.0
+        for i in range(num_cargos):
+            for j in range(num_positions):
+                if solution[i, j] == 1:
+                    if cargo_types[i] == 1:
+                        cg_change += weights[i] * cg_impact[j]
+                    elif cargo_types[i] == 2 and j % 2 == 0 and j < len(cg_impact_2u) * 2:
+                        cg_change += weights[i] * cg_impact_2u[j // 2]
+                    elif cargo_types[i] == 4 and j % 4 == 0 and j < len(cg_impact_4u) * 4:
+                        cg_change += weights[i] * cg_impact_4u[j // 4]
+
+        return pulp.LpStatus[prob.status], cg_change, solution
+    else:
+        # 若求解失败，则返回空结果和错误标志
+        return pulp.LpStatus[prob.status], -1000000, None
+
+# 示例输入和调用
+def main():
+    weights = [500, 800, 1200, 300, 700, 1000, 600, 900]  # 每个货物的质量
+    cargo_names = ['LD3', 'LD3', 'PLA', 'LD3', 'P6P', 'PLA', 'LD3', 'BULK']  # 货物名称
+    cargo_types_dict = {"LD3": 1, "PLA": 2, "P6P": 4, "BULK": 1}  # 货物占位关系
+    positions = list(range(44))  # 44个货位编号
+    cg_impact = [i * 0.1 for i in range(44)]  # 每kg货物对重心index的影响系数 (单个位置)
+    cg_impact_2u = [i * 0.08 for i in range(22)]  # 两个位置组合的影响系数
+    cg_impact_4u = [i * 0.05 for i in range(11)]  # 四个位置组合的影响系数
+    max_positions = 44  # 总货位数量
+
+    status, cg_change, solution = cargo_load_planning_mip(
+        weights, cargo_names, cargo_types_dict, positions, cg_impact, cg_impact_2u, cg_impact_4u, max_positions
+    )
+
+    if status == 'Optimal':
+        print("成功找到最优装载方案！")
+        print("装载方案矩阵:")
+        print(solution)
+
+        print(f"重心的变化量: {cg_change:.2f}")
+
+        # 输出实际分布
+        for i in range(len(weights)):
+            assigned_positions = []
+            for j in range(len(positions)):
+                if solution[i, j] > 0.5:  # 判断位置是否被分配
+                    assigned_positions.append(j)
+            print(f"货物 {cargo_names[i]} (占 {cargo_types_dict[cargo_names[i]]} 单位): 放置位置 -> {assigned_positions}")
+    else:
+        print("未能找到可行解。")
+        print(f"求解状态: {status}")
+
+if __name__ == "__main__":
+    main()

code/optimization baselines/algorithm/MLIP.py

@@ -0,0 +1,137 @@
+import numpy as np
+import pulp
+
+def cargo_load_planning_mip(weights, cargo_names, cargo_types_dict, positions, cg_impact, cg_impact_2u, cg_impact_4u,
+                            max_positions):
+    """
+    使用混合整数规划方法计算货物装载方案，最小化重心的变化量。
+
+    参数:
+        weights (list): 每个货物的质量列表。
+        cargo_names (list): 每个货物的名称。
+        cargo_types_dict (dict): 货物名称和占用的货位数量。
+        positions (list): 可用的货位编号。
+        cg_impact (list): 每个位置每kg货物对重心index的影响系数。
+        cg_impact_2u (list): 两个位置组合的重心影响系数。
+        cg_impact_4u (list): 四个位置组合的重心影响系数。
+        max_positions (int): 总货位的数量。
+
+    返回:
+        result (pulp.LpStatus): 求解状态。
+        cg_change (float): 最优解的重心变化量。
+        solution_matrix (np.ndarray): 最优装载方案矩阵。
+    """
+    # 将货物类型映射为对应的占用单位数
+    cargo_types = [cargo_types_dict[name] for name in cargo_names]
+
+    num_cargos = len(weights)        # 货物数量
+    num_positions = len(positions)   # 可用货位数量
+
+    # 创建优化问题实例
+    prob = pulp.LpProblem("Cargo_Load_Planning", pulp.LpMinimize)
+
+    # 创建决策变量 x_ij (是否将货物i放置在位置j)
+    # 使用字典键 (i,j) 来标识变量
+    x = pulp.LpVariable.dicts("x",
+                              ((i, j) for i in range(num_cargos) for j in range(num_positions)),
+                              cat='Binary')
+
+    # 定义目标函数：最小化重心的变化量
+    objective_terms = []
+    for i in range(num_cargos):
+        for j in range(num_positions):
+            if cargo_types[i] == 1:
+                impact = abs(weights[i] * cg_impact[j])
+            elif cargo_types[i] == 2 and j % 2 == 0 and j < len(cg_impact_2u) * 2:
+                impact = abs(weights[i] * cg_impact_2u[j // 2])
+            elif cargo_types[i] == 4 and j % 4 == 0 and j < len(cg_impact_4u) * 4:
+                impact = abs(weights[i] * cg_impact_4u[j // 4])
+            else:
+                impact = 0
+            objective_terms.append(impact * x[i, j])
+
+    prob += pulp.lpSum(objective_terms), "Total_CG_Change"
+
+    # 约束1：每个货物只能装载到一个位置
+    for i in range(num_cargos):
+        prob += pulp.lpSum([x[i, j] for j in range(num_positions)]) == 1, f"Cargo_{i}_Single_Position"
+
+    # 约束2：每个位置只能装载一个货物
+    for j in range(num_positions):
+        prob += pulp.lpSum([x[i, j] for i in range(num_cargos)]) <= 1, f"Position_{j}_Single_Cargo"
+
+    # 约束3：占用多个位置的货物
+    for i, cargo_type in enumerate(cargo_types):
+        if cargo_type == 2:  # 两个连续位置组合
+            for j in range(0, num_positions - 1, 2):
+                prob += x[i, j] + x[i, j + 1] <= 1, f"Cargo_{i}_Type2_Position_{j}_{j+1}"
+        elif cargo_type == 4:  # 四个连续位置组合
+            for j in range(0, num_positions - 3, 4):
+                prob += x[i, j] + x[i, j + 1] + x[i, j + 2] + x[i, j + 3] <= 1, f"Cargo_{i}_Type4_Position_{j}_{j+3}"
+
+    # 求解问题
+    solver = pulp.PULP_CBC_CMD(msg=False)  # 使用默认的CBC求解器，不显示求解过程
+    prob.solve(solver)
+
+    # 检查求解状态
+    if pulp.LpStatus[prob.status] == 'Optimal':
+        # 构建装载方案矩阵
+        solution = np.zeros((num_cargos, num_positions))
+        for i in range(num_cargos):
+            for j in range(num_positions):
+                var_value = pulp.value(x[i, j])
+                if var_value is not None and var_value > 0.5:
+                    solution[i, j] = 1
+
+        # 计算最终重心变化
+        cg_change = 0.0
+        for i in range(num_cargos):
+            for j in range(num_positions):
+                if solution[i, j] == 1:
+                    if cargo_types[i] == 1:
+                        cg_change += weights[i] * cg_impact[j]
+                    elif cargo_types[i] == 2 and j % 2 == 0 and j < len(cg_impact_2u) * 2:
+                        cg_change += weights[i] * cg_impact_2u[j // 2]
+                    elif cargo_types[i] == 4 and j % 4 == 0 and j < len(cg_impact_4u) * 4:
+                        cg_change += weights[i] * cg_impact_4u[j // 4]
+
+        return solution, cg_change
+    else:
+        # 若求解失败，则返回空结果和错误标志
+        return [], -1000000
+
+# 示例输入和调用
+# def main():
+#     weights = [500, 800, 1200, 300, 700, 1000, 600, 900]  # 每个货物的质量
+#     cargo_names = ['LD3', 'LD3', 'PLA', 'LD3', 'P6P', 'PLA', 'LD3', 'BULK']  # 货物名称
+#     cargo_types_dict = {"LD3": 1, "PLA": 2, "P6P": 4, "BULK": 1}  # 货物占位关系
+#     positions = list(range(44))  # 44个货位编号
+#     cg_impact = [i * 0.1 for i in range(44)]  # 每kg货物对重心index的影响系数 (单个位置)
+#     cg_impact_2u = [i * 0.08 for i in range(22)]  # 两个位置组合的影响系数
+#     cg_impact_4u = [i * 0.05 for i in range(11)]  # 四个位置组合的影响系数
+#     max_positions = 44  # 总货位数量
+#
+#     status, cg_change, solution = cargo_load_planning_mip(
+#         weights, cargo_names, cargo_types_dict, positions, cg_impact, cg_impact_2u, cg_impact_4u, max_positions
+#     )
+#
+#     if status == 'Optimal':
+#         print("成功找到最优装载方案！")
+#         print("装载方案矩阵:")
+#         print(solution)
+#
+#         print(f"重心的变化量: {cg_change:.2f}")
+#
+#         # 输出实际分布
+#         for i in range(len(weights)):
+#             assigned_positions = []
+#             for j in range(len(positions)):
+#                 if solution[i, j] > 0.5:  # 判断位置是否被分配
+#                     assigned_positions.append(j)
+#             print(f"货物 {cargo_names[i]} (占 {cargo_types_dict[cargo_names[i]]} 单位): 放置位置 -> {assigned_positions}")
+#     else:
+#         print("未能找到可行解。")
+#         print(f"求解状态: {status}")
+#
+# if __name__ == "__main__":
+#     main()

code/optimization baselines/algorithm/NL-CPLEX.py

@@ -0,0 +1,143 @@
+import numpy as np
+from scipy.optimize import linprog
+
+
+def cargo_load_planning_nonlinear1(weights, cargo_names, cargo_types_dict, positions, cg_impact, cg_impact_2u, cg_impact_4u,
+                        max_positions):
+    """
+    使用整数线性规划方法计算货物装载方案，最小化重心的变化量。
+
+    参数:
+        weights (list): 每个货物的质量列表。
+        cargo_names (list): 每个货物的名称。
+        cargo_types_dict (dict): 货物名称和占用的货位数量。
+        positions (list): 可用的货位编号。
+        cg_impact (list): 每个位置每kg货物对重心index的影响系数。
+        cg_impact_2u (list): 两个位置组合的重心影响系数。
+        cg_impact_4u (list): 四个位置组合的重心影响系数。
+        max_positions (int): 总货位的数量。
+
+    返回:
+        result.x: 最优装载方案矩阵。
+    """
+    # 将货物类型映射为对应的占用单位数
+    cargo_types = [cargo_types_dict[name] for name in cargo_names]
+
+    num_cargos = len(weights)  # 货物数量
+    num_positions = len(positions)  # 可用货位数量
+
+    # 决策变量：xij (是否将货物i放置在位置j)
+    c = []  # 目标函数系数列表
+    for i in range(num_cargos):
+        for j in range(num_positions):
+            if cargo_types[i] == 1:
+                c.append((weights[i] * cg_impact[j])**2)
+            elif cargo_types[i] == 2 and j % 2 == 0 and j < len(cg_impact_2u) * 2:
+                c.append((weights[i] * cg_impact_2u[j // 2])**2)
+            elif cargo_types[i] == 4 and j % 4 == 0 and j < len(cg_impact_4u) * 4:
+                c.append((weights[i] * cg_impact_4u[j // 4])**2)
+            else:
+                c.append(0)  # 不适合的索引默认影响为0
+
+    # 决策变量约束：xij只能是0或1 (整型约束由 linprog 近似处理)
+    bounds = [(0, 1) for _ in range(num_cargos * num_positions)]
+
+    # 约束1：每个货物只能装载到一个位置
+    A_eq = []
+    b_eq = []
+    for i in range(num_cargos):
+        constraint = [0] * (num_cargos * num_positions)
+        for j in range(num_positions):
+            constraint[i * num_positions + j] = 1
+        A_eq.append(constraint)
+        b_eq.append(1)
+
+    # 约束2：每个位置只能装载一个货物
+    A_ub = []
+    b_ub = []
+    for j in range(num_positions):  # 遍历所有位置
+        constraint = [0] * (num_cargos * num_positions)
+        for i in range(num_cargos):  # 遍历所有货物
+            constraint[i * num_positions + j] = 1
+        A_ub.append(constraint)
+        b_ub.append(1)  # 每个位置最多只能分配一个货物
+
+    # 约束3：占用多个位置的货物
+    for i, cargo_type in enumerate(cargo_types):
+        if cargo_type == 2:  # 两个连续位置组合
+            for j in range(0, num_positions - 1, 2):
+                constraint = [0] * (num_cargos * num_positions)
+                constraint[i * num_positions + j] = 1
+                constraint[i * num_positions + j + 1] = 1
+                A_ub.append(constraint)
+                b_ub.append(1)
+        elif cargo_type == 4:  # 上两个、下两个组合
+            for j in range(0, num_positions - 3, 4):
+                constraint = [0] * (num_cargos * num_positions)
+                constraint[i * num_positions + j] = 1
+                constraint[i * num_positions + j + 1] = 1
+                constraint[i * num_positions + j + 2] = 1
+                constraint[i * num_positions + j + 3] = 1
+                A_ub.append(constraint)
+                b_ub.append(1)
+
+    # 转换为numpy数组
+    A_eq = np.array(A_eq)
+    b_eq = np.array(b_eq)
+    A_ub = np.array(A_ub)
+    b_ub = np.array(b_ub)
+    c = np.array(c)
+
+    # 求解线性规划问题
+    result = linprog(c, A_ub=A_ub, b_ub=b_ub, A_eq=A_eq, b_eq=b_eq, bounds=bounds, method='highs-ds')
+
+    if result.success:
+        # print("成功找到最优装载方案！")
+        solution = result.x.reshape((num_cargos, num_positions))
+        # print("装载方案矩阵:")
+        # print(solution)
+
+        # 计算最终重心变化
+        cg_change = 0
+        for i in range(num_cargos):
+            for j in range(num_positions):
+                if cargo_types[i] == 1:
+                    cg_change += solution[i, j] * weights[i] * cg_impact[j]
+                elif cargo_types[i] == 2 and j % 2 == 0 and j < len(cg_impact_2u) * 2:
+                    cg_change += solution[i, j] * weights[i] * cg_impact_2u[j // 2]
+                elif cargo_types[i] == 4 and j % 4 == 0 and j < len(cg_impact_4u) * 4:
+                    cg_change += solution[i, j] * weights[i] * cg_impact_4u[j // 4]
+        # print(f"重心的变化量: {cg_change:.2f}")
+        return result,cg_change
+        # 输出实际分布
+        # print("货物实际分布:")
+        # for i in range(num_cargos):
+        #     assigned_positions = []
+        #     for j in range(num_positions):
+        #         if solution[i, j] > 0.5:  # 判断位置是否被分配
+        #             assigned_positions.append(j)
+        #     print(f"货物 {cargo_names[i]} (占 {cargo_types[i]} 单位): 放置位置 -> {assigned_positions}")
+    else:
+        result = []
+        return result,-1000000
+
+
+
+
+# # 示例输入
+# def main():
+#     weights = [500, 800, 1200, 300, 700, 1000, 600, 900]  # 每个货物的质量
+#     cargo_names = ['LD3', 'LD3', 'PLA', 'LD3', 'P6P', 'PLA', 'LD3', 'BULK']  # 货物名称
+#     cargo_types_dict = {"LD3": 1, "PLA": 2, "P6P": 4, "BULK": 1}  # 货物占位关系
+#     positions = list(range(44))  # 44个货位编号
+#     cg_impact = [i * 0.1 for i in range(44)]  # 每kg货物对重心index的影响系数 (单个位置)
+#     cg_impact_2u = [i * 0.08 for i in range(22)]  # 两个位置组合的影响系数
+#     cg_impact_4u = [i * 0.05 for i in range(11)]  # 四个位置组合的影响系数
+#     max_positions = 44  # 总货位数量
+#
+#     result = cargo_load_planning_nonlinear1(weights, cargo_names, cargo_types_dict, positions, cg_impact, cg_impact_2u,
+#                                  cg_impact_4u, max_positions)
+#
+#
+# if __name__ == "__main__":
+#     main()

code/optimization baselines/algorithm/PSO-normal.py

@@ -0,0 +1,242 @@
+import numpy as np
+import pyswarms as ps
+
+
+def cargo_load_planning_pso(weights, cargo_names, cargo_types_dict, positions, cg_impact, cg_impact_2u, cg_impact_4u,
+                            max_positions, options=None, swarmsize=100, maxiter=100):
+    """
+    使用粒子群优化方法计算货物装载方案，最小化重心的变化量。
+
+    参数:
+        weights (list): 每个货物的质量列表。
+        cargo_names (list): 每个货物的名称。
+        cargo_types_dict (dict): 货物名称和占用的货位数量。
+        positions (list): 可用的货位编号。
+        cg_impact (list): 每个位置每kg货物对重心index的影响系数。
+        cg_impact_2u (list): 两个位置组合的重心影响系数。
+        cg_impact_4u (list): 四个位置组合的重心影响系数。
+        max_positions (int): 总货位的数量。
+        options (dict, optional): PSO算法的配置选项。
+        swarmsize (int, optional): 粒子群大小。
+        maxiter (int, optional): 最大迭代次数。
+
+    返回:
+        best_solution (np.array): 最优装载方案矩阵。
+        best_cg_change (float): 最优方案的重心变化量。
+    """
+    # 将货物类型映射为对应的占用单位数
+    cargo_types = [cargo_types_dict[name] for name in cargo_names]
+
+    num_cargos = len(weights)  # 货物数量
+    num_positions = len(positions)  # 可用货位数量
+    dimension = num_cargos  # 每个粒子的维度对应每个货物的起始位置
+
+    # 如果未提供options，使用默认配置
+    if options is None:
+        options = {'c1': 0.5, 'c2': 0.3, 'w': 0.9}
+
+    # 定义适应度评估函数
+    def fitness_function(x):
+        """
+        计算每个粒子的适应度值。
+
+        参数:
+            x (numpy.ndarray): 粒子的位置数组，形状为 (n_particles, dimension)。
+
+        返回:
+            numpy.ndarray: 每个粒子的适应度值。
+        """
+        fitness = np.zeros(x.shape[0])
+
+        for idx, particle in enumerate(x):
+            # 将连续位置映射为离散起始位置，根据货物类型对齐
+            start_positions = []
+            penalty = 0
+            cg_change = 0.0
+            occupied = np.zeros(num_positions, dtype=int)
+
+            for i in range(num_cargos):
+                cargo_type = cargo_types[i]
+                pos_continuous = particle[i]
+
+                # 根据货物类型对齐
+                if cargo_type == 1:
+                    start_pos = int(np.round(pos_continuous)) % num_positions
+                elif cargo_type == 2:
+                    start_pos = (int(np.round(pos_continuous)) // 2) * 2
+                    if start_pos >= num_positions - 1:
+                        start_pos = num_positions - 2
+                elif cargo_type == 4:
+                    start_pos = (int(np.round(pos_continuous)) // 4) * 4
+                    if start_pos >= num_positions - 3:
+                        start_pos = num_positions - 4
+                else:
+                    start_pos = 0  # 默认位置
+
+                # 检查边界
+                if start_pos < 0 or start_pos + cargo_type > num_positions:
+                    penalty += 1000
+                    continue
+
+                # 检查对齐
+                if cargo_type == 2 and start_pos % 2 != 0:
+                    penalty += 1000
+                if cargo_type == 4 and start_pos % 4 != 0:
+                    penalty += 1000
+
+                # 检查重叠
+                if np.any(occupied[start_pos:start_pos + cargo_type]):
+                    penalty += 1000
+                else:
+                    occupied[start_pos:start_pos + cargo_type] = 1
+
+                start_positions.append(start_pos)
+
+                # 计算重心变化量
+                if cargo_type == 1:
+                    cg_change += weights[i] * cg_impact[start_pos]
+                elif cargo_type == 2:
+                    cg_change += weights[i] * cg_impact_2u[start_pos // 2]
+                elif cargo_type == 4:
+                    cg_change += weights[i] * cg_impact_4u[start_pos // 4]
+
+            fitness[idx] = cg_change + penalty
+
+        return fitness
+
+    # 设置PSO的边界
+    # 对于每个货物，起始位置的范围根据货物类型对齐
+    lower_bounds = []
+    upper_bounds = []
+    for i in range(num_cargos):
+        cargo_type = cargo_types[i]
+        if cargo_type == 1:
+            lower_bounds.append(0)
+            upper_bounds.append(num_positions - 1)
+        elif cargo_type == 2:
+            lower_bounds.append(0)
+            upper_bounds.append(num_positions - 2)
+        elif cargo_type == 4:
+            lower_bounds.append(0)
+            upper_bounds.append(num_positions - 4)
+        else:
+            lower_bounds.append(0)
+            upper_bounds.append(num_positions - 1)
+
+    bounds = (np.array(lower_bounds), np.array(upper_bounds))
+
+    # 初始化PSO优化器
+    optimizer = ps.single.GlobalBestPSO(n_particles=swarmsize, dimensions=dimension, options=options, bounds=bounds)
+
+    # 运行PSO优化
+    best_cost, best_pos = optimizer.optimize(fitness_function, iters=maxiter)
+
+    # 将最佳位置映射为离散装载方案
+    best_start_positions = []
+    penalty = 0
+    cg_change = 0.0
+    occupied = np.zeros(num_positions, dtype=int)
+
+    for i in range(num_cargos):
+        cargo_type = cargo_types[i]
+        pos_continuous = best_pos[i]
+
+        # 根据货物类型对齐
+        if cargo_type == 1:
+            start_pos = int(np.round(pos_continuous)) % num_positions
+        elif cargo_type == 2:
+            start_pos = (int(np.round(pos_continuous)) // 2) * 2
+            if start_pos >= num_positions - 1:
+                start_pos = num_positions - 2
+        elif cargo_type == 4:
+            start_pos = (int(np.round(pos_continuous)) // 4) * 4
+            if start_pos >= num_positions - 3:
+                start_pos = num_positions - 4
+        else:
+            start_pos = 0  # 默认位置
+
+        # 检查边界
+        if start_pos < 0 or start_pos + cargo_type > num_positions:
+            penalty += 1000
+            best_start_positions.append(start_pos)
+            continue
+
+        # 检查对齐
+        if cargo_type == 2 and start_pos % 2 != 0:
+            penalty += 1000
+        if cargo_type == 4 and start_pos % 4 != 0:
+            penalty += 1000
+
+        # 检查重叠
+        if np.any(occupied[start_pos:start_pos + cargo_type]):
+            penalty += 1000
+        else:
+            occupied[start_pos:start_pos + cargo_type] = 1
+
+        best_start_positions.append(start_pos)
+
+        # 计算重心变化量
+        if cargo_type == 1:
+            cg_change += abs(weights[i] * cg_impact[start_pos])
+        elif cargo_type == 2:
+            cg_change += abs(weights[i] * cg_impact_2u[start_pos // 2])
+        elif cargo_type == 4:
+            cg_change += abs(weights[i] * cg_impact_4u[start_pos // 4])
+
+    total_cg_change = cg_change + penalty
+
+    # 构建装载方案矩阵
+    best_xij = np.zeros((num_cargos, num_positions), dtype=int)
+    for i, start_pos in enumerate(best_start_positions):
+        cargo_type = cargo_types[i]
+        for k in range(cargo_type):
+            pos = start_pos + k
+            if pos < num_positions:
+                best_xij[i, pos] = 1
+
+    # 检查是否有严重惩罚，判断是否找到可行解
+    if total_cg_change >= -999999:
+        return best_xij, total_cg_change
+    else:
+        return [], -1000000
+
+#
+# # 示例输入和调用
+# def main():
+#     weights = [500, 800, 1200, 300, 700, 1000, 600, 900]  # 每个货物的质量
+#     cargo_names = ['LD3', 'LD3', 'PLA', 'LD3', 'P6P', 'PLA', 'LD3', 'BULK']  # 货物名称
+#     cargo_types_dict = {"LD3": 1, "PLA": 2, "P6P": 4, "BULK": 1}  # 货物占位关系
+#     positions = list(range(44))  # 44个货位编号
+#     cg_impact = [i * 0.1 for i in range(44)]  # 每kg货物对重心index的影响系数 (单个位置)
+#     cg_impact_2u = [i * 0.08 for i in range(22)]  # 两个位置组合的影响系数
+#     cg_impact_4u = [i * 0.05 for i in range(11)]  # 四个位置组合的影响系数
+#     max_positions = 44  # 总货位数量
+#
+#     # 设置PSO参数（可选）
+#     options = {'c1': 0.5, 'c2': 0.3, 'w': 0.9}
+#
+#     solution, cg_change = cargo_load_planning_pso(
+#         weights, cargo_names, cargo_types_dict, positions,
+#         cg_impact, cg_impact_2u, cg_impact_4u, max_positions,
+#         options=options, swarmsize=200, maxiter=200
+#     )
+#
+#     if solution is not None and len(solution) > 0:
+#         print("成功找到最优装载方案！")
+#         print("装载方案矩阵:")
+#         print(solution)
+#         print(f"重心的变化量: {cg_change:.2f}")
+#
+#         # 输出实际分布
+#         for i in range(len(weights)):
+#             assigned_positions = []
+#             for j in range(len(positions)):
+#                 if solution[i, j] > 0.5:  # 判断位置是否被分配
+#                     assigned_positions.append(j)
+#             print(f"货物 {cargo_names[i]} (占 {cargo_types_dict[cargo_names[i]]} 单位): 放置位置 -> {assigned_positions}")
+#     else:
+#         print("未找到可行的装载方案。")
+#
+#
+# if __name__ == "__main__":
+#     main()

code/optimization baselines/algorithm/RCH.py

@@ -0,0 +1,207 @@
+import numpy as np
+
+
+def cargo_load_planning_heuristic(weights, cargo_names, cargo_types_dict, positions,
+                                  cg_impact, cg_impact_2u, cg_impact_4u, max_positions,
+                                  max_iterations=1000):
+    """
+    使用两阶段启发式算法计算货物装载方案，最小化重心的变化量。
+
+    参数:
+        weights (list): 每个货物的质量列表。
+        cargo_names (list): 每个货物的名称。
+        cargo_types_dict (dict): 货物名称和占用的货位数量。
+        positions (list): 可用的货位编号。
+        cg_impact (list): 每个位置每kg货物对重心index的影响系数。
+        cg_impact_2u (list): 两个位置组合的重心影响系数。
+        cg_impact_4u (list): 四个位置组合的重心影响系数。
+        max_positions (int): 总货位的数量。
+        max_iterations (int): 优化阶段的最大迭代次数。
+
+    返回:
+        solution (np.array): 最优装载方案矩阵。
+        total_cg_change (float): 最优方案的重心变化量。
+    """
+    # 将货物类型映射为对应的占用单位数
+    cargo_types = [cargo_types_dict[name] for name in cargo_names]
+
+    num_cargos = len(weights)  # 货物数量
+    num_positions = len(positions)  # 可用货位数量
+
+    # 初始化装载方案矩阵
+    solution = np.zeros((num_cargos, num_positions), dtype=int)
+
+    # 标记已占用的位置
+    occupied = np.zeros(num_positions, dtype=int)
+
+    # 按照货物类型（占用单位数降序）和重量降序排序货物
+    sorted_indices = sorted(range(num_cargos), key=lambda i: (-cargo_types[i], -weights[i]))
+
+    # 阶段1：初始装载方案生成
+    for i in sorted_indices:
+        cargo_type = cargo_types[i]
+        feasible_positions = []
+
+        # 根据货物类型确定可行的起始位置
+        if cargo_type == 1:
+            possible_starts = range(0, num_positions)
+        elif cargo_type == 2:
+            possible_starts = range(0, num_positions - 1, 2)
+        elif cargo_type == 4:
+            possible_starts = range(0, num_positions - 3, 4)
+        else:
+            possible_starts = []
+
+        for start in possible_starts:
+            # 检查是否超出边界
+            if start + cargo_type > num_positions:
+                continue
+            # 检查是否与已占用位置重叠
+            if np.any(occupied[start:start + cargo_type]):
+                continue
+            # 计算重心变化量
+            if cargo_type == 1:
+                cg = abs(weights[i] * cg_impact[start])
+            elif cargo_type == 2:
+                cg = abs(weights[i] * cg_impact_2u[start // 2])
+            elif cargo_type == 4:
+                cg = abs(weights[i] * cg_impact_4u[start // 4])
+            feasible_positions.append((start, cg))
+
+        # 如果有可行位置，选择使重心变化最小的位置
+        if feasible_positions:
+            best_start, best_cg = min(feasible_positions, key=lambda x: x[1])
+            solution[i, best_start:best_start + cargo_type] = 1
+            occupied[best_start:best_start + cargo_type] = 1
+        else:
+            # 如果没有可行位置，则尝试分配到任何未占用的位置（可能违反约束）
+            for start in range(0, num_positions - cargo_type + 1):
+                if np.all(occupied[start:start + cargo_type] == 0):
+                    solution[i, start:start + cargo_type] = 1
+                    occupied[start:start + cargo_type] = 1
+                    break
+
+    # 计算初始重心变化量
+    total_cg_change = 0.0
+    for i in range(num_cargos):
+        cargo_type = cargo_types[i]
+        assigned_positions = np.where(solution[i] == 1)[0]
+        if len(assigned_positions) == 0:
+            continue
+        if cargo_type == 1:
+            total_cg_change += abs(weights[i] * cg_impact[assigned_positions[0]])
+        elif cargo_type == 2:
+            total_cg_change += abs(weights[i] * cg_impact_2u[assigned_positions[0] // 2])
+        elif cargo_type == 4:
+            total_cg_change += abs(weights[i] * cg_impact_4u[assigned_positions[0] // 4])
+
+    # 阶段2：装载方案优化
+    for _ in range(max_iterations):
+        improved = False
+        for i in range(num_cargos):
+            cargo_type = cargo_types[i]
+            current_positions = np.where(solution[i] == 1)[0]
+            if len(current_positions) == 0:
+                continue
+            current_start = current_positions[0]
+
+            # 根据货物类型确定可行的起始位置
+            if cargo_type == 1:
+                possible_starts = range(0, num_positions)
+            elif cargo_type == 2:
+                possible_starts = range(0, num_positions - 1, 2)
+            elif cargo_type == 4:
+                possible_starts = range(0, num_positions - 3, 4)
+            else:
+                possible_starts = []
+
+            best_start = current_start
+            best_cg = total_cg_change
+
+            for start in possible_starts:
+                if start == current_start:
+                    continue
+                # 检查是否超出边界
+                if start + cargo_type > num_positions:
+                    continue
+                # 检查是否与已占用位置重叠
+                if np.any(occupied[start:start + cargo_type]):
+                    continue
+                # 计算重心变化量
+                if cargo_type == 1:
+                    new_cg = abs(weights[i] * cg_impact[start])
+                elif cargo_type == 2:
+                    new_cg = abs(weights[i] * cg_impact_2u[start // 2])
+                elif cargo_type == 4:
+                    new_cg = abs(weights[i] * cg_impact_4u[start // 4])
+                else:
+                    new_cg = 0
+
+                # 计算新的总重心变化量
+                temp_cg_change = total_cg_change - (
+                    weights[i] * cg_impact[current_start] if cargo_type == 1 else
+                    weights[i] * cg_impact_2u[current_start // 2] if cargo_type == 2 else
+                    weights[i] * cg_impact_4u[current_start // 4] if cargo_type == 4 else 0
+                ) + new_cg
+
+                # 如果新的重心变化量更小，进行更新
+                if temp_cg_change < best_cg:
+                    best_cg = temp_cg_change
+                    best_start = start
+
+            # 如果找到了更好的位置，进行更新
+            if best_start != current_start:
+                # 释放当前占用的位置
+                occupied[current_start:current_start + cargo_type] = 0
+                solution[i, current_start:current_start + cargo_type] = 0
+
+                # 分配到新的位置
+                solution[i, best_start:best_start + cargo_type] = 1
+                occupied[best_start:best_start + cargo_type] = 1
+
+                # 更新总重心变化量
+                total_cg_change = best_cg
+                improved = True
+
+        if not improved:
+            break  # 如果在一个完整的迭代中没有改进，结束优化
+
+    return solution, total_cg_change
+
+
+# 示例输入和调用
+def main():
+    weights = [500, 800, 1200, 300, 700, 1000, 600, 900]  # 每个货物的质量
+    cargo_names = ['LD3', 'LD3', 'PLA', 'LD3', 'P6P', 'PLA', 'LD3', 'BULK']  # 货物名称
+    cargo_types_dict = {"LD3": 1, "PLA": 2, "P6P": 4, "BULK": 1}  # 货物占位关系
+    positions = list(range(44))  # 44个货位编号
+    cg_impact = [i * 0.1 for i in range(44)]  # 每kg货物对重心index的影响系数 (单个位置)
+    cg_impact_2u = [i * 0.08 for i in range(22)]  # 两个位置组合的影响系数
+    cg_impact_4u = [i * 0.05 for i in range(11)]  # 四个位置组合的影响系数
+    max_positions = 44  # 总货位数量
+
+    solution, cg_change = cargo_load_planning_heuristic(
+        weights, cargo_names, cargo_types_dict, positions,
+        cg_impact, cg_impact_2u, cg_impact_4u, max_positions,
+        max_iterations=1000
+    )
+
+    if solution is not None and solution.size > 0:
+        print("成功找到最优装载方案！")
+        print("装载方案矩阵:")
+        print(solution)
+        print(f"重心的变化量: {cg_change:.2f}")
+
+        # 输出实际分布
+        for i in range(len(weights)):
+            assigned_positions = []
+            for j in range(len(positions)):
+                if solution[i, j] > 0.5:  # 判断位置是否被分配
+                    assigned_positions.append(j)
+            print(f"货物 {cargo_names[i]} (占 {cargo_types_dict[cargo_names[i]]} 单位): 放置位置 -> {assigned_positions}")
+    else:
+        print("未找到可行的装载方案。")
+
+
+if __name__ == "__main__":
+    main()

code/optimization baselines/algorithm/SDCCLPM.py

@@ -0,0 +1,143 @@
+import numpy as np
+from scipy.optimize import linprog
+
+
+def cargo_load_planning_nonlinear2(weights, cargo_names, cargo_types_dict, positions, cg_impact, cg_impact_2u, cg_impact_4u,
+                        max_positions):
+    """
+    使用整数线性规划方法计算货物装载方案，最小化重心的变化量。
+
+    参数:
+        weights (list): 每个货物的质量列表。
+        cargo_names (list): 每个货物的名称。
+        cargo_types_dict (dict): 货物名称和占用的货位数量。
+        positions (list): 可用的货位编号。
+        cg_impact (list): 每个位置每kg货物对重心index的影响系数。
+        cg_impact_2u (list): 两个位置组合的重心影响系数。
+        cg_impact_4u (list): 四个位置组合的重心影响系数。
+        max_positions (int): 总货位的数量。
+
+    返回:
+        result.x: 最优装载方案矩阵。
+    """
+    # 将货物类型映射为对应的占用单位数
+    cargo_types = [cargo_types_dict[name] for name in cargo_names]
+
+    num_cargos = len(weights)  # 货物数量
+    num_positions = len(positions)  # 可用货位数量
+
+    # 决策变量：xij (是否将货物i放置在位置j)
+    c = []  # 目标函数系数列表
+    for i in range(num_cargos):
+        for j in range(num_positions):
+            if cargo_types[i] == 1:
+                c.append((weights[i] * cg_impact[j])**2)
+            elif cargo_types[i] == 2 and j % 2 == 0 and j < len(cg_impact_2u) * 2:
+                c.append((weights[i] * cg_impact_2u[j // 2])**2)
+            elif cargo_types[i] == 4 and j % 4 == 0 and j < len(cg_impact_4u) * 4:
+                c.append((weights[i] * cg_impact_4u[j // 4])**2)
+            else:
+                c.append(0)  # 不适合的索引默认影响为0
+
+    # 决策变量约束：xij只能是0或1 (整型约束由 linprog 近似处理)
+    bounds = [(0, 1) for _ in range(num_cargos * num_positions)]
+
+    # 约束1：每个货物只能装载到一个位置
+    A_eq = []
+    b_eq = []
+    for i in range(num_cargos):
+        constraint = [0] * (num_cargos * num_positions)
+        for j in range(num_positions):
+            constraint[i * num_positions + j] = 1
+        A_eq.append(constraint)
+        b_eq.append(1)
+
+    # 约束2：每个位置只能装载一个货物
+    A_ub = []
+    b_ub = []
+    for j in range(num_positions):  # 遍历所有位置
+        constraint = [0] * (num_cargos * num_positions)
+        for i in range(num_cargos):  # 遍历所有货物
+            constraint[i * num_positions + j] = 1
+        A_ub.append(constraint)
+        b_ub.append(1)  # 每个位置最多只能分配一个货物
+
+    # 约束3：占用多个位置的货物
+    for i, cargo_type in enumerate(cargo_types):
+        if cargo_type == 2:  # 两个连续位置组合
+            for j in range(0, num_positions - 1, 2):
+                constraint = [0] * (num_cargos * num_positions)
+                constraint[i * num_positions + j] = 1
+                constraint[i * num_positions + j + 1] = 1
+                A_ub.append(constraint)
+                b_ub.append(1)
+        elif cargo_type == 4:  # 上两个、下两个组合
+            for j in range(0, num_positions - 3, 4):
+                constraint = [0] * (num_cargos * num_positions)
+                constraint[i * num_positions + j] = 1
+                constraint[i * num_positions + j + 1] = 1
+                constraint[i * num_positions + j + 2] = 1
+                constraint[i * num_positions + j + 3] = 1
+                A_ub.append(constraint)
+                b_ub.append(1)
+
+    # 转换为numpy数组
+    A_eq = np.array(A_eq)
+    b_eq = np.array(b_eq)
+    A_ub = np.array(A_ub)
+    b_ub = np.array(b_ub)
+    c = np.array(c)
+
+    # 求解线性规划问题
+    result = linprog(c, A_ub=A_ub, b_ub=b_ub, A_eq=A_eq, b_eq=b_eq, bounds=bounds, method='highs')
+
+    if result.success:
+        # print("成功找到最优装载方案！")
+        solution = result.x.reshape((num_cargos, num_positions))
+        # print("装载方案矩阵:")
+        # print(solution)
+
+        # 计算最终重心变化
+        cg_change = 0
+        for i in range(num_cargos):
+            for j in range(num_positions):
+                if cargo_types[i] == 1:
+                    cg_change += solution[i, j] * weights[i] * cg_impact[j]
+                elif cargo_types[i] == 2 and j % 2 == 0 and j < len(cg_impact_2u) * 2:
+                    cg_change += solution[i, j] * weights[i] * cg_impact_2u[j // 2]
+                elif cargo_types[i] == 4 and j % 4 == 0 and j < len(cg_impact_4u) * 4:
+                    cg_change += solution[i, j] * weights[i] * cg_impact_4u[j // 4]
+        # print(f"重心的变化量: {cg_change:.2f}")
+        return result,cg_change
+        # 输出实际分布
+        # print("货物实际分布:")
+        # for i in range(num_cargos):
+        #     assigned_positions = []
+        #     for j in range(num_positions):
+        #         if solution[i, j] > 0.5:  # 判断位置是否被分配
+        #             assigned_positions.append(j)
+        #     print(f"货物 {cargo_names[i]} (占 {cargo_types[i]} 单位): 放置位置 -> {assigned_positions}")
+    else:
+        result = []
+        return result,-1000000
+
+
+
+
+# # 示例输入
+# def main():
+#     weights = [500, 800, 1200, 300, 700, 1000, 600, 900]  # 每个货物的质量
+#     cargo_names = ['LD3', 'LD3', 'PLA', 'LD3', 'P6P', 'PLA', 'LD3', 'BULK']  # 货物名称
+#     cargo_types_dict = {"LD3": 1, "PLA": 2, "P6P": 4, "BULK": 1}  # 货物占位关系
+#     positions = list(range(44))  # 44个货位编号
+#     cg_impact = [i * 0.1 for i in range(44)]  # 每kg货物对重心index的影响系数 (单个位置)
+#     cg_impact_2u = [i * 0.08 for i in range(22)]  # 两个位置组合的影响系数
+#     cg_impact_4u = [i * 0.05 for i in range(11)]  # 四个位置组合的影响系数
+#     max_positions = 44  # 总货位数量
+#
+#     result = cargo_load_planning_nonlinear1(weights, cargo_names, cargo_types_dict, positions, cg_impact, cg_impact_2u,
+#                                  cg_impact_4u, max_positions)
+#
+#
+# if __name__ == "__main__":
+#     main()