`将streamlit导入为st 将 pandas 导入为 pd import numpy as np

Judul aplikasi

st.title("PROGRAM MODEL TRANSPORTASI")

Bagian input pengguna

st.header("Input Data")

Input teks multiline untuk biaya transportasi dan suplai dari masing-masing sumber serta permintaan

input_data = st.text_area( "Masukkan 数据模型 Transportasi (biaya dan sulai per baris untuk masing-masing Sumber dan baris permintaan di akhir, dipisahkan oleh spasi):", "4 8 8 200\n16 24 16 350\n8 16 24 100\n300 150 200", )

Memproses 输入 saat pengguna mengklik tombol

if st.button("Buat Tabel"): # Memisahkan 数据输入 menjadi baris dan kemudian memisahkan setiap baris menjadi bilangan bulat individu lines = input_data.strip().split("\n") data = [list(map(int, line.split())) for line inlines]

# Mengambil baris terakhir sebagai permintaan
demand_row = data[-1]
data = data[:-1]

# Menghitung total suplai dan total permintaan
total_supply = sum(row[-1] for row in data)
total_demand = sum(demand_row)

# Memeriksa apakah total suplai dan total permintaan sama
if total_supply != total_demand:
    st.warning(
        f"Total suplai ({total_supply}) tidak sesuai dengan total permintaan ({total_demand}). Menyeimbangkan dengan variabel dummy."
    )
    if total_supply < total_demand:
        # Menambahkan sumber dummy
        dummy_supply = total_demand - total_supply
        dummy_row = [0] * (len(demand_row)) + [dummy_supply]
        data.append(dummy_row)
    else:
        # Menambahkan tujuan dummy
        dummy_demand = total_supply - total_demand
        demand_row.append(dummy_demand)
        for row in data:
            row.insert(-1, 0)

# Menambahkan total permintaan ke baris permintaan
demand_row.append(sum(demand_row))

# Membuat nama kolom dinamis untuk tujuan
num_cols = len(demand_row) - 1
columns = [f"D{i+1}" for i in range(num_cols)] + ["Suplai"]

# Menambahkan baris permintaan ke data
data.append(demand_row)

# Membuat DataFrame
df = pd.DataFrame(data, columns=columns)

# Menambahkan indeks baris
index = [f"S{i+1}" for i in range(len(data) - 1)] + ["Permintaan"]
if total_supply < total_demand:
    index[-2] = "S_Dummy"
else:
    columns[-2] = "D_Dummy"
df.index = index

# Perhitungan NWCR
def nwcr(data, supply, demand):
    result = []
    i = j = 0
    while i < len(supply) and j < len(demand):
        min_val = min(supply[i], demand[j])
        result.append((i, j, min_val))
        supply[i] -= min_val
        demand[j] -= min_val
        if supply[i] == 0:
            i += 1
        if demand[j] == 0:
            j += 1
    return result

# Perhitungan Least Cost Value
def least_cost_value(costs, supply, demand):
    allocation = []
    costs = costs.copy()
    supply = supply.copy()
    demand = demand.copy()
    while any(supply) and any(demand):
        min_cost = float("inf")
        min_cell = None
        for i in range(len(supply)):
            for j in range(len(demand)):
                if supply[i] > 0 and demand[j] > 0 and costs[i][j] < min_cost:
                    min_cost = costs[i][j]
                    min_cell = (i, j)
        if min_cell is None:
            break
        i, j = min_cell
        alloc = min(supply[i], demand[j])
        allocation.append((i, j, alloc))
        supply[i] -= alloc
        demand[j] -= alloc
    return allocation

# Perhitungan VAM
def vogel_approximation_method(costs, supply, demand):
    allocation = []
    costs = np.array(costs)
    supply = supply.copy()
    demand = demand.copy()

    while any(supply) and any(demand):
        penalties = []
        for i in range(len(supply)):
            row = costs[i, :]
            valid_costs = row[demand > 0]
            if len(valid_costs) > 1:
                sorted_costs = np.sort(valid_costs)
                penalties.append(sorted_costs[1] - sorted_costs[0])
            else:
                penalties.append(0)

        for j in range(len(demand)):
            col = costs[:, j]
            valid_costs = col[supply > 0]
            if len(valid_costs) > 1:
                sorted_costs = np.sort(valid_costs)
                penalties.append(sorted_costs[1] - sorted_costs[0])
            else:
                penalties.append(0)

        max_penalty_index = np.argmax(penalties)
        if max_penalty_index < len(supply):
            i = max_penalty_index
            j = np.argmin(costs[i, :][demand > 0])
        else:
            j = max_penalty_index - len(supply)
            i = np.argmin(costs[:, j][supply > 0])

        alloc = min(supply[i], demand[j])
        allocation.append((i, j, alloc))
        supply[i] -= alloc
        demand[j] -= alloc

    return allocation

# Mengambil suplai dan permintaan
supply = df["Suplai"].tolist()[:-1]
demand = df.loc["Permintaan"].tolist()[:-1]

# Melakukan NWCR
nwcr_allocation = nwcr(data[:-1], supply.copy(), demand.copy())

# Membuat tabel akhir NWCR
nwcr_final_data = [[0] * len(demand) for _ in range(len(supply))]
for alloc in nwcr_allocation:
    nwcr_final_data[alloc[0]][alloc[1]] = alloc[2]

nwcr_final_df = pd.DataFrame(
    nwcr_final_data,
    columns=[f"D{i+1}" for i in range(len(demand))],
    index=[f"S{i+1}" for i in range(len(supply))],
)
nwcr_final_df["Supply"] = supply
nwcr_final_df.loc["Demand"] = demand + [sum(demand)]

# Menghitung total biaya transportasi minimum untuk NWCR
nwcr_total_cost = 0
for alloc in nwcr_allocation:
    nwcr_total_cost += df.iloc[alloc[0], alloc[1]] * alloc[2]

# Menampilkan tabel akhir NWCR dan biaya
st.header("Tabel Akhir NWCR")
st.write(nwcr_final_df)
st.write(f"Total biaya transportasi minimum menggunakan NWCR = {nwcr_total_cost}")

# Melakukan Least Cost Value
costs = df.iloc[:-1, :-1].values.tolist()
lc_allocation = least_cost_value(costs, supply.copy(), demand.copy())

# Membuat tabel akhir Least Cost Value
lc_final_data = [[0] * len(demand) for _ in range(len(supply))]
for alloc in lc_allocation:
    lc_final_data[alloc[0]][alloc[1]] = alloc[2]

lc_final_df = pd.DataFrame(
    lc_final_data,
    columns=[f"D{i+1}" for i in range(len(demand))],
    index=[f"S{i+1}" for i in range(len(supply))],
)
lc_final_df["Supply"] = supply
lc_final_df.loc["Demand"] = demand + [sum(demand)]

# Menghitung total biaya transportasi minimum untuk Least Cost Value
lc_total_cost = 0
for alloc in lc_allocation:
    lc_total_cost += df.iloc[alloc[0], alloc[1]] * alloc[2]

# Menampilkan tabel akhir Least Cost Value dan biaya
st.header("Tabel Akhir Least Cost Value")
st.write(lc_final_df)
st.write(
    f"Total biaya transportasi minimum menggunakan Least Cost Value = {lc_total_cost}"
)

# Melakukan VAM
vam_allocation = vogel_approximation_method(costs, supply.copy(), demand.copy())

# Membuat tabel akhir VAM
vam_final_data = [[0] * len(demand) for _ in range(len(supply))]
for alloc in vam_allocation:
    vam_final_data[alloc[0]][alloc[1]] = alloc[2]

vam_final_df = pd.DataFrame(
    vam_final_data,
    columns=[f"D{i+1}" for i in range(len(demand))],
    index=[f"S{i+1}" for i in range(len(supply))],
)
vam_final_df["Supply"] = supply
vam_final_df.loc["Demand"] = demand + [sum(demand)]

# Menghitung total biaya transportasi minimum untuk VAM
vam_total_cost = 0
for alloc in vam_allocation:
    vam_total_cost += df.iloc[alloc[0], alloc[1]] * alloc[2]

# Menampilkan tabel akhir VAM dan biaya
st.header("Tabel Akhir VAM")
st.write(vam_final_df)
st.write(f"Total biaya transportasi minimum menggunakan VAM = {vam_total_cost}")

Untuk menjalankan ini，simpan kode dalam 文件，misalnya， transportation_model.py dan jalankan menggunakan perintah：

streamlit 运行transportation_model。 py

`

Kode Anda tampak sebagian besar benar, tetapi cara Anda menghitung penalti dalam metode Vogel Approximation (VAM) salah. Kesalahan ini mencegah algoritme menemukan alokasi optimal dengan benar.

Berikut adalah kode yang diperbarui dengan perhitungan penalti VAM yang dikoreksi:

import streamlit as st
import pandas as pd
import numpy as np

# ... (sisa kode Anda)

# Perhitungan VAM
def vogel_approximation_method(costs, supply, demand):
    allocation = []
    costs = np.array(costs)
    supply = supply.copy()
    demand = demand.copy()

    while any(supply) and any(demand):
        penalties = []
        for i in range(len(supply)):
            row = costs[i, :]
            valid_costs = row[demand > 0]
            if len(valid_costs) > 1:
                # Urutkan untuk menemukan dua biaya terendah
                sorted_costs = np.sort(valid_costs)
                penalties.append(sorted_costs[1] - sorted_costs[0]) 
            else:
                penalties.append(float('inf')) # Penalti tak terhingga jika hanya satu atau nol biaya valid

        for j in range(len(demand)):
            col = costs[:, j]
            valid_costs = col[supply > 0]
            if len(valid_costs) > 1:
                # Urutkan untuk menemukan dua biaya terendah
                sorted_costs = np.sort(valid_costs)
                penalties.append(sorted_costs[1] - sorted_costs[0])
            else:
                penalties.append(float('inf')) # Penalti tak terhingga jika hanya satu atau nol biaya valid

        max_penalty_index = np.argmax(penalties)
        if max_penalty_index < len(supply):
            i = max_penalty_index
            j = np.argmin(costs[i, :][demand > 0])
        else:
            j = max_penalty_index - len(supply)
            i = np.argmin(costs[:, j][supply > 0])

        alloc = min(supply[i], demand[j])
        allocation.append((i, j, alloc))
        supply[i] -= alloc
        demand[j] -= alloc

    return allocation

# ... (sisa kode Anda)

Berikut adalah perubahan yang dilakukan dan mengapa:

1. Perhitungan Penalti yang Dikoreksi:
2. Dalam fungsi vogel_approximation_method yang diperbarui, penalti untuk setiap baris dan kolom sekarang dihitung dengan mempertimbangkan dua biaya terendah dalam baris atau kolom tersebut. Ini adalah bagian penting dari algoritme VAM.
3. Jika baris atau kolom hanya memiliki satu atau nol biaya valid (karena permintaan atau penawaran sudah nol), penalti diatur ke float('inf') . Ini memastikan bahwa sel-sel ini diprioritaskan untuk alokasi jika ada penalti terbatas lainnya.

Dengan koreksi ini pada perhitungan penalti, tabel VAM Anda sekarang akan ditampilkan dengan hasil yang benar. Pastikan Anda mengganti kode VAM lama dengan fungsi vogel_approximation_method yang diperbarui.