import pandas as pd
    
# 各店舗の名前と要求人数情報の設定
dict_req = {"location": ["tenjin", "hakata"], "num_employees": [2, 3]}
    
# 各従業員の勤務先希望情報の設定
dict_worker_loc = {
    "worker_id": [0, 1, 2, 3, 4],  # 従業員の ID
    "tenjin": [2, 2, 1, 0, 1],  # 各従業員の tenjin 店舗で働きたい希望度
    "hakata": [1, 1, 1, 1, 0],  # 各従業員の hakata 店舗で働きたい希望度
}
    
df_req = pd.DataFrame.from_dict(dict_req, orient="index").T
print("各店舗の要求従業員数")
display(df_req)
df_worker_loc = pd.DataFrame.from_dict(dict_worker_loc, orient="index").T
print("\n各従業員の勤務希望度")
display(df_worker_loc)
    
workers = df_worker_loc["worker_id"].values
locations = df_req["location"].values
    
# 各データのサイズを取得
num_workers = len(workers)
num_locations = len(locations)
    
# 店舗名とそのインデックスをそれぞれkeyとvalueとする辞書の作成
loc2idx = dict((v, i) for i, v in enumerate(df_req["location"].values))
# 店舗インデックスと店舗名をそれぞれkeyとvalueとする辞書の作成
idx2loc = dict((i, v) for i, v in enumerate(df_req["location"].values))

from amplify import VariableGenerator
    
gen = VariableGenerator()
# 従業員 i が店舗 l に割り当てられるか否かを表すバイナリ変数
location_variables = gen.array("Binary", num_workers, num_locations)
    
# 決定変数は5x2の行列となっている。
print(location_variables)

from itertools import product
    
# 勤務不可店舗に関しては、0を予め代入
for i, l in product(range(num_workers), locations):
    worker_req = df_worker_loc.iloc[i][l]
    # 希望度から勤務不可
    if worker_req == 0:
        location_variables[i, loc2idx[l]] = 0
    
## 決定変数の中で、勤務不可店舗に関する要素が0に固定されている
print(location_variables)

w_l = location_variables.sum(axis=0) / df_req["num_employees"].values

from amplify import sum
    
# 充足率の平均の最大化（充足率の負値を最小化）
average_fill_rate_cost = -((w_l.sum() / w_l.size) ** 2)
    
# 充足率分散の最小化
variance_fill_rate_cost = (w_l * w_l).sum() / w_l.size - (w_l.sum() / w_l.size) ** 2
    
# 従業員の希望度最大化（従業員の希望度の負値を最小化）
location_cost = -sum(
    num_workers,
    lambda i: sum(
        num_locations,
        lambda l: df_worker_loc.loc[i][idx2loc[l]] * location_variables[i, l],
    ),
)

from amplify import equal_to, greater_equal, one_hot
    
# ある従業員 i は、同時に1店舗にのみ割り当てられる
location_constarints = sum(one_hot(location_variables[i]) for i in range(num_workers))
    
# ある店舗 l には、その店舗の要求従業員数 r_l 以上の従業員を割り当てる
require_constraints = sum(
    greater_equal(location_variables[:, l], df_req["num_employees"][l])
    for l in range(num_locations)
)

# それぞれの目的関数の係数
loc_priority = 1
ave_fill_priority = 1
var_fill_priority = 10
    
# 目的関数
cost_func = (
    loc_priority * location_cost
    + ave_fill_priority * average_fill_rate_cost
    + var_fill_priority * variance_fill_rate_cost
)

# 制約条件を表すペナルティ関数の重み
constraint_weight = 10
    
# 制約条件
constraints = constraint_weight * (location_constarints + require_constraints)
    
# 目的関数と制約条件を足し合わせ、最適化対象のモデルを作成
model = cost_func + constraints

from amplify import FixstarsClient
from datetime import timedelta
    
# クライアントの設定
client = FixstarsClient()
client.parameters.timeout = timedelta(milliseconds=1000)  # タイムアウトは 1000 ms
# client.token = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"  # ローカル環境等で使用する場合は、Fixstars Amplify AE のアクセストークンを入力してください。

from amplify import solve
    
# 求解し、結果を取得
result = solve(model, client)
    
# 制約条件を満たす解が得られなかった場合は、RuntimeError を出す（重みなどを調整し、再求解）。
if len(result) == 0:
    raise RuntimeError("The given constraints are not satisfied")
values = result.best.values
    
# 変数行列 `location_variables` に対応した形式で解を取り出し
location_solutions = location_variables.evaluate(values)
    
print(location_solutions)

import numpy as np
from collections import defaultdict
    
location_index_list = np.where(np.array(location_solutions) == 1)[1]
dict_df = defaultdict(list)
    
for i, loc_ind in enumerate(location_index_list):
    worker_id = df_worker_loc.loc[i]["worker_id"]
    ## 割り当て先店舗
    loc = locations[loc_ind]
    dict_df["worker_id"].append(worker_id)
    dict_df["allocation"].append(loc)
    
df_result = pd.DataFrame.from_dict(dict_df, orient="index").T
    
print("従業員ごとの割り当て先店舗")
display(df_result)

# df_result 内の `allocation` リストにおいて、各店舗名が現れる回数をカウント = 各店舗に割り当てられた従業員数
num_employees_allocated = df_result["allocation"].value_counts()
fill_rate = df_req.copy()
fill_rate["fill rate"] = [
    df_req.loc[l]["num_employees"] / num_employees_allocated[idx2loc[l]]
    for l in range(num_locations)
]
    
print("店舗ごとの充足率")
display(fill_rate)

import pandas as pd
    
# 各店舗の要求人数情報の設定
dict_req = {
    "location": ["tenjin", "hakata", "akasaka", "gakken"],  # 店舗名
    "num_managers": [1, 1, 1, 1],  # 各店舗の店長役職を有する要求従業員数
    "num_submanagers": [1, 0, 1, 1],  # 各店舗の副店長役職を有する要求従業員数
    "num_employees_any_role": [
        2,
        2,
        2,
        2,
    ],  # 各店舗の要求従業員数（役職有り無しを問わず全員）
}
df_req = pd.DataFrame.from_dict(dict_req, orient="index").T
    
# 各従業員の勤務店舗希望情報の設定
dict_worker_loc = {
    "worker_id": [0, 1, 2, 3, 4, 5, 6, 7, 8],  # 従業員の ID
    "tenjin": [2, 0, 0, 0, 1, 1, 2, 1, 1],  # 各従業員の tenjin 店舗への配置の希望度
    "hakata": [1, 0, 0, 2, 2, 2, 1, 2, 1],  # 各従業員の hakata 店舗への配置の希望度
    "akasaka": [1, 0, 0, 1, 0, 1, 1, 1, 2],  # 各従業員の akasaka 店舗への配置の希望度
    "gakken": [1, 2, 2, 0, 0, 0, 0, 0, 0],  # 各従業員の gakken 店舗への配置の希望度
}
df_worker_loc = pd.DataFrame.from_dict(dict_worker_loc, orient="index").T
    
# 各従業員の役職資格情報の設定
dict_worker_skill = {
    "worker_id": [0, 1, 2, 3, 4, 5, 6, 7, 8],  # 従業員の ID
    "manager": [1, 1, 0, 0, 1, 1, 1, 0, 1],  # 店長の資格がある 1 か否 0 か
    "submanager": [1, 1, 1, 0, 1, 1, 1, 0, 1],  # 副店長の資格がある 1 か否 0 か
    "staff": [1, 1, 1, 1, 1, 1, 1, 1, 1],  # 役職無し従業員の資格がある 1 か否 0 か
}
df_worker_skill = pd.DataFrame.from_dict(dict_worker_skill, orient="index").T

print("店舗ごとの役職別の要求人数")
display(df_req)

print("従業員ごとの各店舗に対する勤務希望度")
display(df_worker_loc)

print("従業員ごとの役職別の資格情報")
display(df_worker_skill)

# 従業員 ID、店舗名、役職名の取得
workers = df_worker_loc["worker_id"].values
locations = df_req["location"].values
roles = ["manager", "submanager", "staff"]
    
# 店舗インデックスと店舗名をそれぞれkeyとvalueとする辞書の作成
idx2loc = {i: v for i, v in enumerate(locations)}
# 店舗名とそのインデックスをそれぞれkeyとvalueとする辞書の作成
loc2idx = {v: i for i, v in enumerate(locations)}
# 役職インデックスと役職名をそれぞれkeyとvalueとする辞書の作成
idx2role = {i: v for i, v in enumerate(roles)}
# 役職名とそのインデックスをそれぞれkeyとvalueとする辞書の作成
role2idx = {v: i for i, v in enumerate(roles)}
    
# 各データサイズを取得
num_workers = len(workers)
num_locations = len(locations)
num_roles = len(roles)

# 従業員 i が役職 j で店舗 l に割り当てられる 1 か否 0 かを表すバイナリ変数
role_variables = VariableGenerator().array(
    "Binary", num_workers, num_roles, num_locations
)
    
# 決定変数は9x3x4の行列となっている。
print(role_variables)

for i, l in product(range(num_workers), locations):
    worker_req = df_worker_loc.iloc[i][l]
    if worker_req == 0:
        # 希望度から、該当する店舗 l において、全ての役職で割り当て不可
        role_variables[i, :, loc2idx[l]] = 0
    
for i, j in product(range(num_workers), roles):
    worker_skill = df_worker_skill.iloc[i][j]
    if worker_skill == 0:
        # 従業員 i の役職資格情報から、全ての店舗で当該の役職に対する割り当て不可
        role_variables[i, role2idx[j], :] = 0
    
# 勤務不可能店舗・役職に関する決定変数要素が0に固定されていることを確認
print(role_variables)

location_variables = role_variables.sum(axis=1)
display(location_variables)

# 充足率の計算
w_l = location_variables.sum(axis=0) / df_req["num_employees_any_role"].values

# 充足率の平均の最大化（充足率の負値を最小化）
average_fill_rate_cost = -((w_l.sum() / w_l.size) ** 2)
    
# 充足率分散の最小化
variance_fill_rate_cost = (w_l * w_l).sum() / w_l.size - (w_l.sum() / w_l.size) ** 2
    
# 従業員の希望度最大化（従業員の希望度の負値を最小化）
location_cost = -sum(
    num_workers,
    lambda i: sum(
        num_locations,
        lambda l: df_worker_loc.loc[i][idx2loc[l]] * location_variables[i][l],
    ),
)

# ある従業員 i は、同時に1店舗にのみ割り当てられる
location_constarints = sum(one_hot(location_variables[i]) for i in range(num_workers))
    
# 各店舗 l が要求する人数の役職あり従業員 j を割り当てる
req_manager_constraints = sum(
    equal_to(role_variables[:, 0, l], df_req["num_managers"][l])
    for l in range(num_locations)
)
req_submanager_constraints = sum(
    equal_to(role_variables[:, 1, l], df_req["num_submanagers"][l])
    for l in range(num_locations)
)
    
# 各店舗 l には、その店舗の要求従業員数 r_l 以上の従業員（役職有り無しに関わらない全従業員の総数）を割り当てる
req_employee_constraints = sum(
    greater_equal(location_variables[:, l], df_req["num_employees_any_role"][l])
    for l in range(num_locations)
)

# それぞれの目的関数の係数
loc_priority = 1
ave_fill_priority = 1
var_fill_priority = 10
    
# 目的関数
cost_func = (
    loc_priority * location_cost
    + ave_fill_priority * average_fill_rate_cost
    + var_fill_priority * variance_fill_rate_cost
)
    
# 制約条件を表すペナルティ関数の重み
constraint_weight = 10
    
# 制約条件
constraints = constraint_weight * (
    location_constarints
    + req_manager_constraints
    + req_submanager_constraints
    + req_employee_constraints
)
    
# 目的関数と制約条件を足し合わせ、最適化対象のモデルを作成
model = cost_func + constraints

# モデルをソルバーに渡して求解し、結果を取得
result = solve(model, client)
    
# 制約条件を満たす解が得られなかった場合は、RuntimeError を出す（重みなどを調整し、再求解）。
if len(result) == 0:
    raise RuntimeError("The given constraints are not satisfied")
values = result.best.values
    
# 変数行列 `location_variables` に対応した形式で解を取り出し
location_solutions = location_variables.evaluate(values)
    
# 変数行列 `role_variables` に対応した形式で解を取り出し
role_solutions = role_variables.evaluate(values)

import numpy as np
from collections import defaultdict
    
# role_solutions=1 である、役職及び店舗のインデックスを取得
(role_index_list, loc_index_list) = np.where(np.array(role_solutions) == 1)[1:]
dict_df = defaultdict(list)
for i, (j, l) in enumerate(zip(role_index_list, loc_index_list)):
    worker_id = df_worker_loc.loc[i]["worker_id"]
    ## 割り当てられた役職
    role = roles[j]
    ## 割り当て先店舗
    loc = locations[l]
    dict_df["worker_id"].append(worker_id)
    dict_df["role"].append(role)
    dict_df["location"].append(loc)
    
df_result = pd.DataFrame.from_dict(dict_df, orient="index").T
    
print("従業員ごとの店舗と役職の割当て")
display(df_result)

dict_result_alloc = defaultdict(lambda: defaultdict(int))
for loc, role in product(locations, roles):
    dict_result_alloc[loc][role] = 0
    
for i in range(len(df_result)):
    data = df_result.loc[i]
    role = data["role"]
    location = data["location"]
    dict_result_alloc[location][role] += 1
    
df_result_alloc = pd.DataFrame.from_dict(dict_result_alloc, orient="index")
    
print("店舗ごとの役職別の割り当て人数")
display(df_result_alloc)

# 各店舗の要求人数情報のラベル ['num_managers' 'num_submanagers' 'num_employees_any_role']
num_roles_labels = df_req.columns.values[1 : 1 + num_roles]
    
dict_result_fill_rate = defaultdict(defaultdict)
# 各店舗ごとに充足率を計算
for l in range(len(df_result_alloc)):
    data = df_result_alloc.iloc[l]  # 店舗 l の df_result_alloc
    loc = data.name  # 店舗名
    num_req_non_staff = 0  # 各店舗、役職有り従業員の要求数を格納する変数
    # 各役職ごとに充足率を計算。
    for j in range(len(roles)):
        # 各店舗・各役職ごとの要求従業員数
        num_required = df_req[df_req["location"] == loc][num_roles_labels[j]].item()
        # 各店舗の要求従業員数 df_req の最後の要素は、役職有り無しを問わず全ての従業員数なので、役職無し従業員数は、全ての従業員数から役職有り従業員数 num_req_non_staff を減算。
        if j == len(roles) - 1:
            num_required -= num_req_non_staff
        else:
            num_req_non_staff += num_required
        # 各店舗・各役職ごとの割り当て従業員数
        num_allocated = data[roles[j]].item()
        # 充足率を計算。要求従業員数がゼロの場合、N/Aを代入
        if num_required > 0:
            dict_result_fill_rate[loc][f"{roles[j]} (fill rate)"] = (
                num_allocated / num_required
            )
        else:
            dict_result_fill_rate[loc][f"{roles[j]} (fill rate)"] = "N/A"
    
df_result_fill_rate = pd.DataFrame.from_dict(dict_result_fill_rate, orient="index")
    
print("店舗ごとの役職別の充足率")
display(df_result_fill_rate)

# 各店舗の要求人数情報の設定
dict_req = dict(
    location=["tenjin", "hakata"],  # 店舗名
    nun_managers=[1, 1],  # 各店舗の店長役職を有する要求従業員数
    num_submanagers=[0, 1],  # 各店舗の副店長役職を有する要求従業員数
    filleting=[1, 1],  # 「捌き」調理スキル量
    nigiri=[1, 2],  # 「握り」調理スキル量
    soup=[2, 2],  # 「汁物」調理スキル量
    a_la_carte=[2, 2],  # 「一品」調理スキル量
    num_floor_staffs=[1, 1],  # ホールスタッフ
)
df_req = pd.DataFrame.from_dict(dict_req, orient="index").T
    
# 各従業員の勤務店舗希望情報の設定
dict_worker_loc = dict(
    worker_id=[0, 1, 2, 50, 43],  # 従業員の ID
    tenjin=[2, 1, 1, 1, 1],  # 各従業員の tenjin 店舗で働きたい希望度
    hakata=[1, 2, 1, 1, 1],  # 各従業員の hakata 店舗で働きたい希望度
)
df_worker_loc = pd.DataFrame.from_dict(dict_worker_loc, orient="index").T
    
# 各従業員の役職資格、スキル情報の設定
dict_worker_skill = dict(
    worker_id=[0, 1, 2, 50, 43],  # 従業員の ID
    manager=[1, 1, 0, 0, 0],  # 店長の資格がある 1 か否 0 か
    submanager=[1, 1, 0, 1, 1],  # 副店長の資格がある 1 か否 0 か
    staff=[1, 1, 1, 1, 1],  # 役職無し従業員の資格がある 1 か否 0 か
    filleting=[2, 2, 0, 1, 1],  # 捌き調理スキルのスキル量
    nigiri=[2, 2, 0, 2, 2],  # 握り調理スキルのスキル量
    soup=[2, 2, 0, 0, 0],  # 汁物調理スキルのスキル量
    a_la_carte=[2, 2, 0, 1, 1],  # 一品調理スキルのスキル量
)
df_worker_skill = pd.DataFrame.from_dict(dict_worker_skill, orient="index").T

print("店舗ごとの役職別の要求人数")
display(df_req)

print("従業員ごとの各店舗に対する勤務希望度")
display(df_worker_loc)

print("従業員ごとの役職別のスキル情報")
display(df_worker_skill)

# 従業員 ID、店舗名、役職名、役割名、調理スキル名の取得
workers = df_worker_loc["worker_id"].values
locations = df_req["location"].values
roles = ["manager", "submanager", "staff"]
# 役割名
assigns = ["floor", "kitchen"]
# 調理スキル名
skills = ["filleting", "nigiri", "soup", "a_la_carte"]
    
# 店舗インデックスと店舗名をそれぞれkeyとvalueとする辞書の作成
idx2loc = dict((i, v) for i, v in enumerate(locations))
# 店舗名とそのインデックスをそれぞれkeyとvalueとする辞書の作成
loc2idx = dict((v, i) for i, v in enumerate(locations))
# 役職インデックスと役職名をそれぞれkeyとvalueとする辞書の作成
idx2role = dict((i, v) for i, v in enumerate(roles))
# 役職名とそのインデックスをそれぞれkeyとvalueとする辞書の作成
role2idx = dict((v, i) for i, v in enumerate(roles))
# 調理スキルインデックスと調理スキル名をそれぞれkeyとvalueとする辞書の作成
idx2skill = dict((i, v) for i, v in enumerate(skills))
# 調理スキル名とそのインデックスをそれぞれkeyとvalueとする辞書の作成
skill2idx = dict((v, i) for i, v in enumerate(skills))
    
# 各データサイズを取得
num_workers = len(workers)
num_locations = len(locations)
num_roles = len(roles)
num_assigns = len(assigns)
num_skills = len(skills)

# 従業員iが役職jで店舗lに勤務することを表す決定変数
gen = VariableGenerator()
role_variables = gen.array("Binary", num_workers, num_roles, num_locations)
    
# 従業員iが役割hで店舗lに勤務することを表す決定変数
assign_variables = gen.array("Binary", num_workers, num_assigns, num_locations)

for i, l in product(range(num_workers), locations):
    worker_req = df_worker_loc.iloc[i][l]
    if worker_req == 0:
        # 全ての役職で店舗割当が不可
        role_variables[i, :, loc2idx[l]] = 0
        # 全ての役割で店舗割当が不可
        assign_variables[i, :, loc2idx[l]] = 0
    
for i, j in product(range(num_workers), roles):
    worker_skill = df_worker_skill.iloc[i][j]
    if worker_skill == 0:
        # 全ての店舗で役職が不可
        role_variables[i, role2idx[j], :] = 0
    
for i in range(num_workers):
    if all(df_worker_skill.iloc[i][k] == 0 for k in skills):
        # 全ての店舗で役割(キッチン担当)が不可
        assign_variables[i, 1, :] = 0
    
    
# 勤務不可店舗・役職に関する変数が0に固定されている
print(role_variables)
# 担当不可役店舗・役割に関する変数が0に固定されている
print(assign_variables)

location_variables = assign_variables.sum(axis=1)
display(location_variables)

from amplify import PolyArray
    
# 各店舗、各調理スキルに対する充足率 w_kl の計算
w_kl = PolyArray(
    [
        sum(
            df_worker_skill[idx2skill[k]] * assign_variables[:, 1, l],
        )
        / df_req[idx2skill[k]][l]
        for k in range(num_skills)
        for l in range(num_locations)
    ]
)

# 充足率の平均の最大化（充足率の負値を最小化）
average_fill_rate_cost = -((w_kl.sum() / w_kl.size) ** 2)
    
# 充足率分散の最小化
variance_fill_rate_cost = (w_kl * w_kl).sum() / w_kl.size - (
    w_kl.sum() / w_kl.size
) ** 2
    
# 従業員の希望度最大化（従業員の希望度の負値を最小化）
location_cost = -sum(
    num_workers,
    lambda i: sum(
        num_locations,
        lambda l: df_worker_loc.loc[i][idx2loc[l]] * location_variables[i, l],
    ),
)

# ある従業員 i は同時に1店舗にのみ割り当てられる
location_constarints = sum(one_hot(location_variables[i]) for i in range(num_workers))
    
# 各店舗 l が要求する人数に等しい役職有り従業員 (j=0 or 1) が割り当てられる
req_manager_constraints = sum(
    equal_to(role_variables[:, 0, l], df_req["nun_managers"][l])
    for l in range(num_locations)
)
req_submanager_constraints = sum(
    equal_to(role_variables[:, 1, l], df_req["num_submanagers"][l])
    for l in range(num_locations)
)
    
# 各店舗 l が要求する人数に等しいホール担当 (h=0) の従業員が割り当てられる
req_hall_constraints = sum(
    equal_to(assign_variables[:, 0, l], df_req["num_floor_staffs"][l])
    for l in range(num_locations)
)
    
# 決定変数 P と M を関連付ける制約条件
role_assign_constraints = sum(
    equal_to(
        (role_variables.sum(axis=1))[i, l] - (assign_variables.sum(axis=1))[i, l], 0
    )
    for i in range(num_workers)
    for l in range(num_locations)
)

# それぞれの目的関数の係数
loc_priority = 1
ave_fill_priority = 1
var_fill_priority = 10
    
# 目的関数
cost_func = (
    loc_priority * location_cost
    + ave_fill_priority * average_fill_rate_cost
    + var_fill_priority * variance_fill_rate_cost
)
    
# 制約条件を表すペナルティ関数の重み
constraint_weight = 10
    
# 制約条件
constraints = constraint_weight * (
    location_constarints
    + req_manager_constraints
    + req_submanager_constraints
    + req_hall_constraints
    + role_assign_constraints
)
    
# 目的関数と制約条件を足し合わせ、最適化対象のモデルを作成
model = cost_func + constraints

# モデルをソルバーに渡して求解し、結果を取得
result = solve(model, client)
    
# 制約条件を満たす解が得られなかった場合は、RuntimeError を出す（重みなどを調整し、再求解）。
if len(result) == 0:
    raise RuntimeError("The given constraints are not satisfied")
values = result.best.values
    
# 割り当て店舗に関する決定変数行列 `location_variables` に対応した形式で解を取り出し
location_solutions = location_variables.evaluate(values)
    
# 割当店舗と役職に関する決定変数行列 `role_variables` に対応した形式で解を取り出し
role_solutions = role_variables.evaluate(values)
    
# 割当店舗と役割に関する決定変数行列 `assign_variables` に対応した形式で解を取り出し
assign_solutions = assign_variables.evaluate(values)

import numpy as np
from collections import defaultdict
    
(role_index_list, loc_index_list) = np.where(np.array(role_solutions) == 1)[1:]
dict_df = defaultdict(list)
    
for i, (j, l) in enumerate(zip(role_index_list, loc_index_list)):
    ## 配属勤務地
    worker_id = df_worker_loc.loc[i]["worker_id"]
    role = roles[j]
    loc = locations[l]
    dict_df["worker_id"].append(worker_id)
    dict_df["role"].append(role)
    dict_df["location"].append(loc)
    
df_result = pd.DataFrame.from_dict(dict_df, orient="index").T
    
print("従業員ごとの店舗と役職の割当て")
display(df_result)

(assign_list, loc_index_list) = np.where(np.array(assign_solutions) == 1)[1:]
    
dict_result_loc = defaultdict(lambda: defaultdict(int))
    
for i, (j, l) in enumerate(zip(assign_list, loc_index_list)):
    assign = assigns[j]
    worker_id = df_worker_loc.loc[i]["worker_id"]
    loc = locations[l]
    if assign == "kitchen":
        # kitchenならば、すべての調理スキルの足し算を行う。
        for skill in skills:
            dict_result_loc[loc][skill] += df_worker_skill.loc[i][skill]
    else:
        # ホールスタッフとして割り当てられた従業員数もカウント
        dict_result_loc[loc]["floor"] += 1
    
df_result_loc = pd.DataFrame.from_dict(dict_result_loc, orient="index")
    
dict_result = defaultdict(defaultdict)
    
for i in range(len(df_result_loc)):
    loc = df_result_loc.iloc[i].name
    # すべての調理スキルに対して充足率を計算
    for skill in skills:
        require_num_skill = df_req[df_req["location"] == loc][skill].item()
        satisfy_num_skill = df_result_loc.iloc[i][skill].item()
        dict_result[loc][
            f"{skill} (fill rate)"
        ] = f"{satisfy_num_skill/require_num_skill}"
    # ホールスタッフの従業員数の充足率を計算
    require_num_skill = df_req[df_req["location"] == loc]["num_floor_staffs"].item()
    satisfy_num_skill = df_result_loc.iloc[i]["floor"].item()
    dict_result[loc][
        "floor staffs (fill rate)"
    ] = f"{satisfy_num_skill/require_num_skill}"
    
df_result_skills = pd.DataFrame.from_dict(dict_result, orient="index")
    
print("店舗ごとの要求スキル量に対する充足率")
display(df_result_skills)

dict_result_alloc = defaultdict(lambda: defaultdict(int))
for loc, role in product(locations, roles):
    dict_result_alloc[loc][role] = 0
    
for i in range(len(df_result)):
    data = df_result.loc[i]
    role = data["role"]
    location = data["location"]
    dict_result_alloc[location][role] += 1
    
df_result_alloc = pd.DataFrame.from_dict(dict_result_alloc, orient="index")
    
print("店舗ごとの役職別の割り当て人数")
display(df_result_alloc)

# 各店舗の要求人数情報のラベル ['num_managers' 'num_submanagers']
num_roles_labels = df_req.columns.values[1:num_roles]
    
dict_result_fill_rate = defaultdict(defaultdict)
# 各店舗ごとに充足率を計算
for l in range(len(df_result_alloc)):
    data = df_result_alloc.iloc[l]  # 店舗 l の df_result_alloc
    loc = data.name  # 店舗名
    # 各役職ごとに充足率を計算。
    for j in range(len(roles) - 1):
        # 各店舗・各役職ごとの要求従業員数
        num_required = df_req[df_req["location"] == loc][num_roles_labels[j]].item()
        # 各店舗・各役職ごとの割り当て従業員数
        num_allocated = data[roles[j]].item()
        # 充足率を計算。要求従業員数がゼロの場合、N/Aを代入
        if num_required > 0:
            dict_result_fill_rate[loc][f"{roles[j]} (fill rate)"] = (
                num_allocated / num_required
            )
        else:
            dict_result_fill_rate[loc][f"{roles[j]} (fill rate)"] = "N/A"
    
df_result_fill_rate = pd.DataFrame.from_dict(dict_result_fill_rate, orient="index")
    
print("店舗ごとの役職別の充足率")
display(df_result_fill_rate)

従業員 $i$	博多店 ($l=0$)	天神店 ($l=1$)
$0$	$L_{0,0}$	$L_{0,1}$
$1$	$L_{1,0}$	$L_{1,1}$
$2$	$L_{2,0}$	$L_{2,1}$
$3$	$L_{3,0}$	$L_{3,1}$
$4$	$L_{4,0}$	$L_{4,1}$

飲食店の従業員割り当て問題¶

ステップ1¶

1.1. 定式化¶

集合¶

定数¶

決定変数¶

目的関数¶

制約条件¶

1.2. データ作成¶

1.3. Amplify による実装¶

1.4. 求解¶

結果の確認¶

ステップ2¶

2.1. 定式化¶

集合¶

定数¶

決定変数¶

目的関数¶

制約条件¶

2.2. データ作成¶

2.3. Amplify による実装¶

2.4. 求解¶

結果の確認¶

ステップ3¶

3.1. 定式化¶

集合¶

定数¶

決定変数¶

目的関数¶

制約条件¶

3.2. データ作成¶

3.3. Amplify による実装¶

3.4. 求解¶

結果の確認¶