function Cost = CostFunction_EV_HSO_VT(solution)
    % Lấy các biến toàn cục
    global T price_grid base_load clusters delta_t num_clusters

    % --- Trọng số (Weight) để cân bằng 2 mục tiêu ---
    % Đây là "nút vặn" để bạn điều chỉnh:
    % - Alpha = 0:    Giống hệt code cũ (chỉ quan tâm GIÁ RẺ).
    % - Alpha > 0:    Bắt đầu quan tâm đến việc LÀM PHẲNG PHỤ TẢI.
    %
    % BẠN CẦN THỬ NGHIỆM GIÁ TRỊ NÀY (ví dụ: 1e5, 1e6, 1e7)
    % Alpha càng lớn, phụ tải sẽ càng PHẲNG (nhưng chi phí có thể TĂNG).
    % Alpha càng nhỏ, chi phí càng RẺ (nhưng phụ tải GỒ GHỀ).
    
    Alpha = 5e6; % <-- THAY ĐỔI GIÁ TRỊ NÀY ĐỂ THỬ NGHIỆM

    % -----------------------------------------------------------------
    
    % Giải nén 'solution' thành ma trận P_ev
    P_ev = reshape(solution, T, num_clusters)'; 
    P_ev_total = sum(P_ev, 1)'; 
    Total_Load = base_load + P_ev_total;
    
    %% MỤC TIÊU 1: GIẢM THIỂU CHI PHÍ VẬN HÀNH
    Cost_Operation = sum(price_grid .* Total_Load * delta_t);
    
    %% MỤC TIÊU 2: LÀM PHẲNG PHỤ TẢI (GIẢM ĐỘ LỆCH CHUẨN)
    % Chúng ta muốn Total_Load càng bằng phẳng càng tốt.
    % Độ lệch chuẩn (std) đo lường sự "gồ ghề".
    % Chúng ta sẽ phạt thuật toán nếu std(Total_Load) cao.
    Cost_Flatness = std(Total_Load);

    %% XỬ LÝ RÀNG BUỘC (PHẠT)
    Penalty = 0;
    Big_Penalty_Factor = 1e9; 

    % Ràng buộc 1: Sạc đủ năng lượng
    for c = 1:num_clusters
        E_demand = clusters(c).E_demand_total;
        E_charged = sum(P_ev(c, :)) * delta_t;
        Penalty = Penalty + Big_Penalty_Factor * abs(E_demand - E_charged);
    end

    %% TỔNG CHI PHÍ (ĐA MỤC TIÊU)
    % Cost = (Chi phí vận hành) + (Hệ số Alpha * Chi phí gồ ghề) + (Phạt)
    %
    % *Ghi chú: Chúng ta chuẩn hóa (normalize) 2 mục tiêu 
    % về thang 0-1 để trọng số Alpha dễ điều chỉnh hơn.
    
    % Chuẩn hóa Cost_Operation (ước lượng)
    % Giả sử chi phí tệ nhất là sạc tất cả vào giờ đắt nhất (10.0)
    % và chi phí tốt nhất là chỉ sạc cho base_load.
    Worst_Cost = sum(price_grid .* (base_load + sum(clusters(1).P_rated_total + clusters(2).P_rated_total)) * delta_t);
    Best_Cost = sum(price_grid .* base_load * delta_t);
    Norm_Cost_Op = (Cost_Operation - Best_Cost) / (Worst_Cost - Best_Cost + eps); % Thêm eps để tránh chia cho 0
    
    % Chuẩn hóa Cost_Flatness (ước lượng)
    % std tệ nhất là dồn hết vào 1 giờ, std tốt nhất là 0 (phẳng tuyệt đối)
    Worst_Std = std(base_load + [sum(clusters(1).E_demand_total + clusters(2).E_demand_total)/delta_t; zeros(T-1, 1)]);
    Best_Std = 0;
    Norm_Cost_Flat = (Cost_Flatness - Best_Std) / (Worst_Std - Best_Std + eps);

    % Sử dụng trọng số cho 2 mục tiêu đã chuẩn hóa:
    % (1-w) cho Chi phí, w cho Làm phẳng
    w = 0.25; % <-- Đặt trọng số 50% chi phí, 50% làm phẳng
             % Bạn có thể thay đổi (ví dụ w = 0.2 để ưu tiên chi phí hơn)

    % Thay thế Alpha bằng cách tính có trọng số chuẩn hóa:
    Cost = (1-w) * Norm_Cost_Op + w * Norm_Cost_Flat + Penalty;

    % Bỏ qua chuẩn hóa và dùng Alpha (đơn giản hơn nhưng khó chỉnh):
    % Cost = Cost_Operation + (Alpha * Cost_Flatness) + Penalty;
end