# 必要なライブラリをインポートする
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), "です。")

import networkx as nx
import matplotlib.pyplot as plt

# グラフの定義
G = nx.Graph()
G.add_edge(0, 1, weight=4)
G.add_edge(0, 2, weight=3)
G.add_edge(1, 3, weight=2)
G.add_edge(2, 3, weight=5)
G.add_edge(2, 4, weight=6)
G.add_edge(3, 4, weight=1)

# 最短経路の計算
shortest_path = nx.shortest_path(G, source=0, target=4, weight='weight')

# 結果の表示
print(f"The shortest path from node 0 to node 4 is: {shortest_path}")

# グラフの可視化
pos = nx.spring_layout(G)
nx.draw_networkx_nodes(G, pos, node_color='lightblue')
nx.draw_networkx_edges(G, pos)
nx.draw_networkx_labels(G, pos)
edge_labels = {(u, v): d['weight'] for u, v, d in G.edges(data=True)}
nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
plt.axis('off')
plt.show()

import pulp

# 問題を定義
problem = pulp.LpProblem('Optimization Problem', pulp.LpMinimize)

# 変数を定義
p1 = pulp.LpVariable('p1', lowBound=0, upBound=100, cat='Continuous')
p2 = pulp.LpVariable('p2', lowBound=0, upBound=50, cat='Continuous')

# 目的関数を定義
problem += 10*p1 + 20*p2, 'Total Cost'

# 制約条件を定義
problem += p1 + p2 >= 150, 'Demand'
problem += p1 <= 100, 'Capacity of Plant 1'
problem += p2 <= 50, 'Capacity of Plant 2'

# 問題を解く
problem.solve()

# 結果を出力
print(f'Optimal solution found with total cost of {problem.objective.value():.2f}')
print(f'Plant 1 generates {p1.value()} MW')
print(f'Plant 2 generates {p2.value()} MW')