import pulp

# ①問題を定義する
problem = pulp.LpProblem("Job Scheduling", pulp.LpMinimize)

# ②各ジョブをどのマシンで実行するかを決定する変数を作成する
# ジョブAをマシン1で実行する場合、変数A_1の値は1になる
# ジョブAをマシン2で実行する場合、変数A_2の値は1になる
A_1 = pulp.LpVariable("A_1", lowBound=0, cat='Binary')
A_2 = pulp.LpVariable("A_2", lowBound=0, cat='Binary')
B_1 = pulp.LpVariable("B_1", lowBound=0, cat='Binary')
B_2 = pulp.LpVariable("B_2", lowBound=0, cat='Binary')
C_1 = pulp.LpVariable("C_1", lowBound=0, cat='Binary')
C_2 = pulp.LpVariable("C_2", lowBound=0, cat='Binary')
D_1 = pulp.LpVariable("D_1", lowBound=0, cat='Binary')
D_2 = pulp.LpVariable("D_2", lowBound=0, cat='Binary')

# ③目的関数を定義する（すべてのジョブが完了するのに必要な時間を最小化する）
problem += 2*A_1 + 2*A_2 + 3*B_1 + 3*B_2 + 2*C_1 + 2*C_2 + 4*D_1 + 4*D_2

# ④制約条件(1)を定義する（各ジョブは1つのマシンで実行されなければならない）
problem += A_1 + A_2 == 1
problem += B_1 + B_2 == 1
problem += C_1 + C_2 == 1
problem += D_1 + D_2 == 1

# ⑤制約条件(2)を定義する（各マシンは同時に実行できるジョブの数に制限がある）
problem += A_1 + B_1 + C_1 + D_1 <= 2
problem += A_2 + B_2 + C_2 + D_2 <= 2

# ⑥問題を解く
status = problem.solve()

# ⑦結果を表示する
print("Status:", pulp.LpStatus[status])
print("Minimum Time:", pulp.value(problem.objective))
print("A_1:", pulp.value(A_1))
print("A_2:", pulp.value(A_2))
print("B_1:", pulp.value(B_1))
print("B_2:", pulp.value(B_2))
print("C_1:", pulp.value(C_1))
print("C_2:", pulp.value(C_2))
print("D_1:", pulp.value(D_1))
print("D_2:", pulp.value(D_2))

import pulp

# ①問題を初期化
problem = pulp.LpProblem("マーケティング最適化問題", pulp.LpMaximize)

# ②変数を定義
a = pulp.LpVariable("Aの広告費用", lowBound=0)
b = pulp.LpVariable("Bの広告費用", lowBound=0)
c = pulp.LpVariable("Cの広告費用", lowBound=0)

# ③目的関数を定義
problem += 300*a + 200*b + 150*c, "利益の合計"

# ④制約条件を定義
problem += a + b + c <= 10000, "広告予算の合計"
problem += a <= 2000, "Aの広告費用の上限"
problem += b <= 1500, "Bの広告費用の上限"
problem += c <= 1000, "Cの広告費用の上限"

# ⑤問題を解く
status = problem.solve()

# ⑥結果を出力
print(f"ステータス: {pulp.LpStatus[status]}")
print(f"最大利益: {problem.objective.value()}")
print(f"Aの広告費用: {a.value()}")
print(f"Bの広告費用: {b.value()}")
print(f"Cの広告費用: {c.value()}")

# 必要なライブラリをインポートする
import pulp

# 問題を定義する
problem = pulp.LpProblem('Construction Project', pulp.LpMinimize)

# 変数を定義する
a = pulp.LpVariable('a', lowBound=0, cat='Continuous')
b = pulp.LpVariable('b', lowBound=0, cat='Continuous')
c = pulp.LpVariable('c', lowBound=0, cat='Continuous')
d = pulp.LpVariable('d', lowBound=0, cat='Continuous')
e = pulp.LpVariable('e', lowBound=0, cat='Continuous')
f = pulp.LpVariable('f', lowBound=0, cat='Continuous')

# 制約式を定義する

# 各作業の所要日数
problem += a >= 2
problem += b >= 3
problem += c >= 4
problem += d >= 2
problem += e >= 3
problem += f >= 4

# 作業A, B, Cは同時に開始することができる
# a + 2 <= dは、作業Dを開始する前に、作業Aが完了している必要があることを表している
# b + 3 <= cは、作業Cを開始する前に、作業Bが完了している必要があることを表している
problem += a + 2 <= d
problem += b + 3 <= c

# 作業Cが完了した後、作業Eを開始する
# c + 4 <= eは、作業Eを開始する前に、作業Cが完了している必要があることを表している
problem += c + 4 <= e

# 作業DとEは同時に開始することができる
# d + 2 <= fは、作業Fを開始する前に、作業Dが完了している必要があることを表している
# e + 3 <= fは、作業Fを開始する前に、作業Eが完了している必要があることを表している
problem += d + 2 <= f
problem += e + 3 <= f

# 目的関数を定義する
problem += f

# 問題を解く
status = problem.solve()

# 結果を表示する
print(f"Status: {pulp.LpStatus[status]}")
print(f"Optimal Solution:")
print(f"\ta: {a.value():.2f}")
print(f"\tb: {b.value():.2f}")
print(f"\tc: {c.value():.2f}")
print(f"\td: {d.value():.2f}")
print(f"\te: {e.value():.2f}")
print(f"\tf: {f.value():.2f}")

# それぞれの作業の開始時期を計算する
start_a = a.value()
start_b = b.value()
start_c = c.value()
start_d = d.value()
start_e = e.value()
start_f = f.value()

# 結果を表示する
print("Task Schedule:")
print(f"\tTask A starts at day {start_a:.2f}")
print(f"\tTask B starts at day {start_b:.2f}")
print(f"\tTask C starts at day {start_c:.2f}")
print(f"\tTask D starts at day {start_d:.2f}")
print(f"\tTask E starts at day {start_e:.2f}")
print(f"\tTask F starts at day {start_f:.2f}")

# 必要なライブラリをインポート
import pulp

# 問題を初期化
problem = pulp.LpProblem("Factory Market Problem", pulp.LpMinimize)

# 工場と市場の数
factories = ["Factory 1", "Factory 2", "Factory 3", "Factory 4", "Factory 5"]
markets = ["Market 1", "Market 2", "Market 3", "Market 4", "Market 5"]

# 各工場の製品の生産量（変数）
production = pulp.LpVariable.dicts("Production", factories, lowBound=0)

# 各市場に必要な製品の量（定数）
demand = {"Market 1": 20, "Market 2": 25, "Market 3": 30, "Market 4": 20, "Market 5": 15}

# 各工場が各市場に供給する製品の量（変数）
shipments = pulp.LpVariable.dicts("Shipments", (factories, markets), lowBound=0)

# 目的関数を設定
problem += pulp.lpSum([500 * production[i] for i in factories]) + pulp.lpSum([300 * shipments[i][j] for i in factories for j in markets])

# 制約条件を追加
for j in markets:
    problem += pulp.lpSum([shipments[i][j] for i in factories]) == demand[j]

for i in factories:
    problem += pulp.lpSum([shipments[i][j] for j in markets]) <= production[i]

# 問題を解く
problem.solve()

# 結果を表示
for i in factories:
    for j in markets:
        if shipments[i][j].value() > 0:
            print(f"{i} から {j} へ {shipments[i][j].value()} だけ製品を供給します。")

from pulp import *

# ①各果物の単価、在庫、需要量を設定
prices = {"apple": 100, "banana": 80, "orange": 120}
inventory = {"apple": 200, "banana": 150, "orange": 100}
demand = {"apple": 100, "banana": 50, "orange": 75}

# ②変数
apple_qty = LpVariable("apple_qty", lowBound=0, cat='Integer')
banana_qty = LpVariable("banana_qty", lowBound=0, cat='Integer')
orange_qty = LpVariable("orange_qty", lowBound=0, cat='Integer')

# ③問題の定義
prob = LpProblem("Fruit Buying Problem", LpMaximize)

# ④目的関数
prob += prices["apple"] * apple_qty + prices["banana"] * banana_qty + prices["orange"] * orange_qty

# ⑤制約条件
prob += apple_qty <= inventory["apple"]
prob += banana_qty <= inventory["banana"]
prob += orange_qty <= inventory["orange"]
prob += apple_qty + banana_qty + orange_qty >= demand["apple"] + demand["banana"] + demand["orange"]
prob += apple_qty >= demand["apple"]
prob += banana_qty >= demand["banana"]
prob += orange_qty >= demand["orange"]

# ⑥最適化の実行
prob.solve()

# ⑦結果の表示
print("Apple quantity: ", apple_qty.value())
print("Banana quantity: ", banana_qty.value())
print("Orange quantity: ", orange_qty.value())
print("Maximum profit: ", value(prob.objective))

# ①pulpライブラリをインポート
import pulp

# ②制約条件を定義する
problem = pulp.LpProblem('Flight Schedule', pulp.LpMaximize)

# ③便ごとに決定変数を作成する
flight_AB = pulp.LpVariable('Flight_AB', lowBound=0, cat='Integer')
flight_AC = pulp.LpVariable('Flight_AC', lowBound=0, cat='Integer')
flight_BC = pulp.LpVariable('Flight_BC', lowBound=0, cat='Integer')

# ④目的関数を設定する
problem += 1000 * flight_AB + 1500 * flight_AC + 1200 * flight_BC

# ⑤制約条件を追加する
problem += flight_AB <= 50
problem += flight_AC <= 70
problem += flight_BC <= 80

problem += flight_AB <= 8
problem += flight_AC <= 11
problem += flight_BC <= 12

problem += flight_AB + flight_AC <= 70
problem += flight_AB + flight_BC <= 60
problem += flight_AC + flight_BC <= 75

# ⑥最適化を実行する
problem.solve()

# ⑦結果を表示する
print('Flight AB:', pulp.value(flight_AB))
print('Flight AC:', pulp.value(flight_AC))
print('Flight BC:', pulp.value(flight_BC))
print('Total profit:', pulp.value(problem.objective))

from pulp import *

# 問題設定
servers = ["Server1", "Server2", "Server3"]
spec = {"Server1": {"CPU": 4, "Memory": 16, "Storage": 500},
        "Server2": {"CPU": 2, "Memory": 8, "Storage": 250},
        "Server3": {"CPU": 8, "Memory": 32, "Storage": 1000}}
costs = {"Server1": 100, "Server2": 50, "Server3": 200}
demands = {"CPU": 10, "Memory": 32, "Storage": 800}

# モデル定義
prob = LpProblem("Server Allocation Problem", LpMinimize)

# 変数定義
servers_vars = LpVariable.dicts("Server", servers, lowBound=0, upBound=None, cat="Integer")

# 目的関数
prob += lpSum([costs[s] * servers_vars[s] for s in servers])

# 制約条件
for r in spec["Server1"].keys():
    prob += lpSum([spec[s][r] * servers_vars[s] for s in servers]) >= demands[r]

# 解法
prob.solve()

# 結果出力
print("Total cost: {}".format(value(prob.objective)))
for s in servers:
    print("{}: {}".format(s, value(servers_vars[s])))

from pulp import *

# 問題を定義
prob = LpProblem('Blood_Transfusion', LpMinimize)

# 変数を定義
blood_type_A = LpVariable('Blood_Type_A', lowBound=0, cat='Integer')
blood_type_B = LpVariable('Blood_Type_B', lowBound=0, cat='Integer')
blood_type_O = LpVariable('Blood_Type_O', lowBound=0, cat='Integer')

# 目的関数を定義
prob += 10 * blood_type_A + 20 * blood_type_B + 30 * blood_type_O

# 制約条件を定義
prob += blood_type_A + blood_type_B + blood_type_O >= 100
prob += blood_type_A >= 20
prob += blood_type_B >= 30
prob += blood_type_O >= 40

# 最適化を実行
prob.solve()

# 結果を表示
print('Blood Type A: ', blood_type_A.value())
print('Blood Type B: ', blood_type_B.value())
print('Blood Type O: ', blood_type_O.value())
print('Total Cost: ', value(prob.objective))

# PuLPをインポートする
from pulp import *

# データを定義する
users = ['User 1', 'User 2', 'User 3', 'User 4']
songs = ['Song 1', 'Song 2', 'Song 3', 'Song 4']
ratings = {
    ('User 1', 'Song 1'): 3,
    ('User 1', 'Song 2'): 4,
    ('User 1', 'Song 3'): 5,
    ('User 1', 'Song 4'): 2,
    ('User 2', 'Song 1'): 5,
    ('User 2', 'Song 2'): 4,
    ('User 2', 'Song 3'): 2,
    ('User 2', 'Song 4'): 3,
    ('User 3', 'Song 1'): 4,
    ('User 3', 'Song 2'): 5,
    ('User 3', 'Song 3'): 3,
    ('User 3', 'Song 4'): 4,
    ('User 4', 'Song 1'): 2,
    ('User 4', 'Song 2'): 3,
    ('User 4', 'Song 3'): 4,
    ('User 4', 'Song 4'): 5
}
time_limits = {
    'User 1': 60,
    'User 2': 90,
    'User 3': 120,
    'User 4': 60
}

# 問題を定義する
prob = LpProblem("Music Recommendation", LpMinimize)

# 変数を定義する
x = LpVariable.dicts('x', [(u, s) for u in users for s in songs], cat='Binary')

# 目的関数を定義する
prob += lpSum([x[(u, s)] * ratings[(u, s)] for u in users for s in songs])

# 制約条件を追加する
for u in users:
    prob += lpSum([x[(u, s)] for s in songs]) <= len(songs) // 2, f"User {u} - Song count"
    prob += lpSum([x[(u, s)] * ratings[(u, s)] for s in songs]) >= 3, f"User {u} - Minimum rating"
    prob += lpSum([x[(u, s)] * ratings[(u, s)] for s in songs]) <= 5, f"User {u} - Maximum rating"
    prob += lpSum([x[(u, s)] * ratings[(u, s)] for s in songs]) * 5 <= time_limits[u], f"User

import networkx as nx
import matplotlib.pyplot as plt

G = nx.DiGraph()
G.add_edge('A', 'B', weight=4)
G.add_edge('A', 'C', weight=2)
G.add_edge('B', 'D', weight=5)
G.add_edge('C', 'D', weight=1)

nx.draw(G, with_labels=True)
plt.show()

shortest_path = nx.shortest_path(G, source='A', target='D', weight='weight')
print("最短経路は", shortest_path, "です。")

import networkx as nx
import matplotlib.pyplot as plt

G = nx.Graph()
G.add_weighted_edges_from([('A', 'B', 4), ('A', 'H', 8), ('B', 'C', 8), ('B', 'H', 11), ('C', 'D', 7), ('C', 'F', 4), ('C', 'I', 2), ('D', 'E', 9), ('D', 'F', 14), ('E', 'F', 10), ('F', 'G', 2), ('G', 'H', 1), ('G', 'I', 6), ('H', 'I', 7)])

nx.draw(G, with_labels=True)
plt.show()

T = nx.minimum_spanning_tree(G)
print("最小全域木の辺は", T.edges(data=True), "です。")