def solve_problem(model):
# set client and parameters
client = FixstarsClient()
client.token = "lJLkgFpKzukTUGnr8F3tjrPJZlO8N0bX"
client.parameters.timeout = 5000
# set solver
solver = Solver(client)
# get result
result = solver.solve(model)
# extract value of objective function and binary variables
obj, values = result[0].energy, result[0].values
# get values of constraints
broken = model.check_constraints(values)
return obj, values, broken
def solve(self,
c_weight: float = 3,
timeout: int = 1000,
num_unit_step: int = 10) -> Setlist:
"""
Args:
c_weight (float): 時間制約の強さ
timeout (int, optional): Fixstars AE のタイムアウト[ms] (デフォルト: 10000)
num_unit_step (int, optional): Fixstars AE のステップ数 (デフォルト: 10)
Returns:
Setlist: セットリスト
"""
self.q = gen_symbols(BinaryPoly, self.num_tracks)
energy_function = self.energy(c_weight)
model = BinaryQuadraticModel(energy_function)
fixstars_client = FixstarsClient()
fixstars_client.token = os.environ.get("FIXSTARS_API_TOKEN")
fixstars_client.parameters.timeout = timeout
fixstars_client.parameters.num_unit_steps = num_unit_step
amplify_solver = Solver(fixstars_client)
amplify_solver.filter_solution = False
result = amplify_solver.solve(model)
q_values = decode_solution(self.q, result[0].values)
tracks = [self.candidates[i] for i, v in enumerate(q_values) if v == 1]
total_time = 0
user_scores = np.zeros(self.num_users)
for track in tracks:
user_scores += np.array(track.p)
total_time += track.duration_ms
return Setlist(tracks=tracks,
scores=user_scores.tolist(),
score_sum=user_scores.sum(),
score_avg=user_scores.mean(),
score_var=user_scores.var(),
total_time=total_time)
from amplify import IsingPoly, gen_symbols, Solver, decode_solution
from amplify.client import FixstarsClient
# クライアントの設定
client = FixstarsClient() # Fixstars Optigan
client.parameters.timeout = 1000 # タイムアウト1秒
client.token = "i5G6Ei3DKlGv2n6hsWBSBzWrmffLN4vn" #20210011まで有効
client.parameters.outputs.duplicate = True # 同じエネルギー値の解を列挙するオプション（解が複数個ある場合）
# 数の集合Aに対応する数のリスト
A = [2, 10, 3, 8, 5, 7, 9, 5, 3, 2]
# len(A): 変数の数
n = len(A)
# イジング変数を生成
s = gen_symbols(IsingPoly, n)
# 目的関数の構築: イジング
f = IsingPoly()
for i in range(n):
f += s[i] * A[i]
f = f ** 2
# ソルバーの構築
solver = Solver(client)
# 問題を入力してマシンを実行
result = solver.solve(f)
def find_feasible_solution(self):
"""find a feasible locations with makespan, found -> set self.used_edges
"""
# create variables
q = []
index = 0
for t in range(self.makespan):
q.append([])
for v in range(self.field["size"]):
l = len(self.field["adj"][v])+1 # +1 -> stay at the current location
q[-1].append(
amplify.gen_symbols( amplify.BinaryPoly, index, (1, l) )
)
index += l
# set starts
constraints_starts = [
equal_to(sum_poly( q[0][v][0] ), 1) # q[timestep][node][0]
for v in self.instance["starts"]
]
for v in range(self.field["size"]):
if v in self.instance["starts"]:
continue
# other locations
for i in range(len(q[0][v][0])):
q[0][v][0][i] = amplify.BinaryPoly(0)
# set goals
constraints_goals = [
equal_to(sum_poly([ q[-1][u][0][ self.field["adj"][u].index(v) ]
for u in self.field["adj"][v] ] +
[ q[-1][v][0][ len(self.field["adj"][v]) ] ]),
1)
for v in self.instance["goals"]
]
for v in range(self.field["size"]):
# other locations
for i in range(len(self.field["adj"][v])):
if self.field["adj"][v][i] not in self.instance["goals"]:
q[-1][v][0][i] = amplify.BinaryPoly(0)
if v not in self.instance["goals"]:
q[-1][v][0][-1] = amplify.BinaryPoly(0)
# upper bound, in
constraints_in = [
less_equal(sum_poly([ q[t][u][0][ self.field["adj"][u].index(v) ]
for u in self.field["adj"][v] ] +
[ q[t][v][0][ len(self.field["adj"][v]) ] ]),
1)
for v, t in product(range(self.field["size"]), range(0, self.makespan-1))
]
# upper bound, out
constraints_out = [
less_equal(sum_poly( q[t][v][0] ),
1)
for v, t in product(range(self.field["size"]), range(1, self.makespan))
]
# continuity
constraints_continuity = [
equal_to(sum_poly([ q[t][u][0][ self.field["adj"][u].index(v) ]
for u in self.field["adj"][v] ] +
[ q[t][v][0][ len(self.field["adj"][v]) ] ])
-
sum_poly( q[t+1][v][0] ),
0)
for v, t in product(range(self.field["size"]), range(0, self.makespan-1))
]
# branching
for v in range(self.field["size"]):
if not self.field["body"][v]:
continue
# unreachable vertexes from starts
for t in range(0, min(self.DIST_TABLE_FROM_STARTS[v], self.makespan)):
for i in range(len(q[t][v][0])):
q[t][v][0][i] = amplify.BinaryPoly(0)
# unreachable vertexes to goals
for t in range(max(self.makespan - self.DIST_TABLE_FROM_GOALS[v] + 1, 0), self.makespan):
for i in range(len(q[t][v][0])):
q[t][v][0][i] = amplify.BinaryPoly(0)
# set occupied vertex
for v in range(self.field["size"]):
if self.field["body"][v]:
continue
for t in range(0, self.makespan):
q[t][v][0][-1] = amplify.BinaryPoly(0)
# create model
model = sum(constraints_starts)
model += sum(constraints_goals)
if len(constraints_in) > 0:
model += sum(constraints_in)
if len(constraints_out) > 0:
model += sum(constraints_out)
if len(constraints_continuity) > 0:
model += sum(constraints_continuity)
# setup client
client = FixstarsClient()
client.token = os.environ['TOKEN']
client.parameters.timeout = self.timeout
# solve
solver = amplify.Solver(client)
result = solver.solve(model)
if len(result) > 0:
self.used_edges = amplify.decode_solution(q, result[0].values)
from amplify import *
from amplify.constraint import *
from amplify.client import FixstarsClient
import os
client = FixstarsClient()
client.token = os.environ['AMPLIFY_TOKEN']
client.parameters.timeout = 5000
N,M,K = map(int,input().split()) # N: 時間数, M: バイトの人数, K: グループの個数
A = [list(map(int,input().split())) for _ in range(M)]
B = [list(map(int,input().split())) for _ in range(K)]
C = [list(map(int,input().split())) for _ in range(M)]
cost1_weight = 1 # 勤務時間平均化の重み
cost2_weight = N*N*4 # 必要人数の重み
cost3_weight = N*N*N # 勤務可能かどうかの重み
cost4_weight = N*N*N # グループの制限の重み
cost5_weight = N*N # 勤務回数最小化の重み
q = gen_symbols(BinaryPoly, M, N, K)
# q[i][j][k] := バイト i が時間 j にグループ k として勤務するかどうか
cost1 = BinaryPoly()
mean = BinaryPoly()
for i in range(M):
for j in range(K):
for k in range(N):
mean += q[i][k][j]
from amplify import BinaryPoly, BinaryQuadraticModel, gen_symbols, Solver
from amplify.client import FixstarsClient
q = gen_symbols(BinaryPoly, 2)
f = 1 - q[0] * q[1]
model = BinaryQuadraticModel(f)
client = FixstarsClient()
client.token = "CxVcQ2gwOawevU/7itsRGkAph9wAXwck"
client.parameters.timeout = 1000 # タイムアウト1秒
solver = Solver(client)
result = solver.solve(model)
for solution in result:
print(f"energy = {solution.energy}\nvalues = {solution.values}")