def solveIt(inputData):
# Modify this code to run your optimization algorithm
# parse the input
lines = inputData.split('\n')
firstLine = lines[0].split()
items = int(firstLine[0])
capacity = int(firstLine[1])
values = []
weights = []
for i in range(1, items+1):
line = lines[i]
parts = line.split()
values.append(int(parts[0]))
weights.append(int(parts[1]))
items = len(values)
c=values
A=[weights]
b=[capacity]
e=[-1]
intIndices=range(1,items+1)
lower=[0]*items
upper=[1]*items
# a trivial greedy algorithm for filling the knapsack
# it takes items in-order until the knapsack is full
value = 0
weight = 0
taken = []
lp=lp_maker(c, A, b, e, lower, upper,intIndices)
lpsolve('set_timeout',lp,100)
lpsolve('solve', lp)
obj=lpsolve('get_objective', lp)
x=lpsolve('get_variables', lp)[0]
lpsolve('delete_lp', lp)
# [obj, x, duals] = lp_solve(c, A, b, e, lower, upper,intIndices)
# for i in range(0, items):
# if weight + weights[i] <= capacity:
# taken.append(1)
# value += values[i]
# weight += weights[i]
# else:
# taken.append(0)
value=obj
taken=x
# prepare the solution in the specified output format
outputData = str(int(value)) + ' ' + str(0) + '\n'
outputData += ' '.join(map(lambda x:str(int(x)), taken))
return outputData
def solve(self,xlist,X,rX):
#print xlist
if len(xlist) == 1:
if rX[0] > 0:
X[abs(rX[0])-1] = 1
elif rX[0] < 0:
X[abs(rX[0])-1] = 0
rlist = [1]
return numpy.array(rlist)
tlist = [numpy.abs(xlist).tolist()]
r1 = numpy.sum(numpy.extract(numpy.greater(xlist,0), xlist))
r2 = numpy.sum(numpy.extract(numpy.less(xlist,0), xlist))
r = 1#r1 + abs(r2) - 1
tlistr = [1]#[r]
eqlist = [1]#[0]
for i in xrange(len(xlist)):
sX = numpy.zeros(len(xlist),numpy.int)
sX[i] = 1
tlist.append(sX.tolist())
tlistr.append(1)
eqlist.append(-1)
for i in xrange(len(xlist)):
sX = numpy.zeros(len(xlist),numpy.int)
sX[i] = 1
tlist.append(sX.tolist())
tlistr.append(0)
eqlist.append(1)
for i in xrange(len(rX)):
sX = numpy.zeros(len(xlist),numpy.int)
if X[abs(rX[i])-1] != -1:
sX[i] = 1
tlist.append(sX.tolist())
tlistr.append(X[abs(rX[i])-1])
eqlist.append(0)
lp = lp_maker(xlist.tolist(), tlist, tlistr, eqlist, None, None)
lpsolve('solve', lp)
rlist = lpsolve('get_variables', lp)[0]
lpsolve('delete_lp', lp)
return numpy.array(rlist)
from lp_maker import *
f = [143, 60]
A = [[120, 210], [110, 30], [1, 1]]
b = [15000, 4000, 75]
lp = lp_maker(f, A, b, [-1, -1, -1], None, None, None, 1, 0)
solvestat = lpsolve('solve', lp)
obj = lpsolve('get_objective', lp)
print obj
x = lpsolve('get_variables', lp)[0]
print x
lpsolve('delete_lp', lp)
def execute_lp(speeds, search_speeds, depots, colors, C, Csp, pts):
# speeds -> list of robots speeds
# depots -> list of robots depots points in the "local" indexation
# colors -> list of color types in char representation ('b', 'r', 'g', ...)
# C -> distance cost matrix
# pts -> list of nodes positions
# PolC -> polinomial coefficients for the virtual graph (ONLY TO PLOT THE RESULT)
# set_uv -> list of active edges (ONLY TO PLOT THE RESULT)
n = len(C) #number of nodes
m = n * (n - 1) #number of edges
R = len(speeds) #number of robots
"""
print "\n\n-------------------------------------\n-------------------------------------"
print "Here is speeds: ", speeds
print "Here is search_speeds: ", search_speeds
print "Here is depots: ", depots
print "Here is colors:", colors
print "C: ", C
print "C_sp: ", C_sp
print "pts: ", pts
print "-------------------------------------\n-------------------------------------\n\n"
"""
w_s = [0, 12, 0, 12]
#Definition of the edges
E = [[0 for i in range(2)] for j in range(m)]
k = 0
for i in range(n):
for j in range(n):
if (i != j):
E[k][0] = i
E[k][1] = j
k = k + 1
"""
print '\nE = '
for k in range(m):
print E[k][:]
#"""
# ---------- ---------- ----------
#Definition of the cost matrix
#C = np.matrix(C)
#Csp = np.matrix(Csp)
C_l = []
Csp_l = []
for r in range(R):
#exec('C_%d = C/float(speeds[r]) + C_sp*(2*pi/float(search_speeds[r]))' % (r))
#exec('C_%d = C_%d.tolist()' % (r,r))
C_l.append(C)
Csp_l.append(C)
for i in range(len(C)):
for j in range(len(C[0])):
C_l[r][i][j] = C[i][j] / float(speeds[r])
Csp_l[r][i][j] = Csp[i][j] / float(search_speeds[r])
#C = C.tolist()
#C_sp = C_sp.tolist()
"""
for r in range(R):
print ''
exec("print 'C_%d = '" % r)
for k in range(n):
exec ("print C_%d[k][:]" % r)
"""
# ---------- ---------- ----------
#Addition of the heuristic cost based on EUCLIDIAN DISTANCE
#"""
#C_check0 = [0 for i in range(len(C))]
#C_check1 = [0 for i in range(len(C))]
for r in range(R):
#exec ('C_%d = np.matrix(C_%d)' % (r, r))
for i in range(n):
for j in range(n):
gamma = 1
heuristica_i = C_l[r][depots[r]][i]
heuristica_j = C_l[r][depots[r]][j]
#heuristica = (heuristica_i + heuristica_j) / 2.0
heuristica = min([heuristica_i, heuristica_j])
#exec ('C_%d[i,j] = C_%d[i,j] + gamma*heuristica' % (r, r))
C_l[r][i][j] = C_l[r][i][j] + gamma * heuristica
"""
#Only to plot (after) the values of the heuristic costs - CAN BE REMOVED
if r == 0:
C_check0[i] = gamma*heuristica
if r == 1:
C_check1[i] = gamma*heuristica
"""
#exec ('C_%d = C_%d.tolist()' % (r, r))
#"""
"""
for r in range(R):
print ''
exec("print 'C_%d = '" % r)
for k in range(n):
exec ("print C_%d[k][:]" % r)
"""
# ---------- ---------- ----------
#Definition of the x variables bounds
vlb = []
vub = []
#Bouds of "X" variables
for i in range(R * m):
vlb.append(0)
vub.append(1)
# Bouds of "F" variable
vlb.append(0 * n)
vub.append(1000 * n) #big positive number
# ---------- ---------- ----------
#Definition of the cost vector
c = []
#Cost of "x" variables
for k in range(R * m):
c.append(0)
# Cost of "F" variable
c.append(1)
"""
#Cost of "x" variables
for r in range(R):
for i in range(n):
for j in range(n):
if (i != j):
#c.append(C[i][j] / speeds[r])
exec('c.append(C_%d[%d][%d])' % (r,i,j))
#Cost of the "F" variable
c.append(0)
"""
# ---------- ---------- ----------
# "Arival constraints" ---------- ---------- ----------
Aeq1 = [[0 for i in range(R * m)] for j in range(n - len(set(depots)))]
count_line = -1
for j in range(n): # 0 until n-1
if (not j in depots): # if j belongs to V^
count_line = count_line + 1
for r in range(R):
for k in range(m): # 0 until m-1
if (E[k][1] == j):
Aeq1[count_line][r * m + k] = 1
beq1 = [1 for i in range(n - len(set(depots)))]
"""
print '\nAeq1 (',len(Aeq1),'x',len(Aeq1[0]),') = '
#print np.matrix(Aeq1)
for k in range(len(Aeq1)):
print Aeq1[k][:]
print '\nbeq1 = ', beq1
"""
#---------- ---------- ---------- ---------- ---------- ----------
#"Flux conservation constraints" ---------- ---------- ----------
Aeq2 = [[0 for i in range(R * m)] for j in range(R * n)]
for r in range(R):
for p in range(n): # 0 until n-1
for k in range(0, m): # 0 until m-1
if (E[k][1] == p):
Aeq2[r * n + p][r * m + k] = 1
if (E[k][0] == p):
Aeq2[r * n + p][r * m + k] = -1
beq2 = [0 for i in range(R * n)]
"""
print '\nAeq2 (',len(Aeq2),'x',len(Aeq2[0]),') = '
for k in range(len(Aeq2)):
print Aeq2[k][:]
print '\nbeq2 = ', beq2
"""
#---------- ---------- ---------- ---------- ---------- ----------
#"Depot constraints" ---------- ---------- ----------
Aeq3 = [[0 for i in range(R * m)] for j in range(R)]
for r in range(R):
for k in range(0, m): # 0 until m-1
if (E[k][1] == depots[r]): #???? is depot right???? yes
Aeq3[r][r * m + k] = 1
beq3 = [1 for i in range(R)]
"""
print '\nAeq3 (',len(Aeq3),'x',len(Aeq3[0]),') = '
for k in range(len(Aeq3)):
print Aeq3[k][:]
print '\nbeq3 = ', beq3
"""
#---------- ---------- ---------- ---------- ---------- ----------
#Joining all equality constraints ---------- ---------- ----------
Aeq = []
Aeq = Aeq + Aeq1 + Aeq2 + Aeq3
beq = []
beq = beq + beq1 + beq2 + beq3
#Adding 'F' variable
for k in range(len(Aeq)):
Aeq[k].append(0)
"""
print '\nAeq (',len(Aeq),'x',len(Aeq[0]),') = '
for k in range(len(Aeq)):
print Aeq[k][:]
print '\nsize of Aeq:', len(Aeq),'x',len(Aeq[0])
print '\nbeq = ', beq
"""
#---------- ---------- ---------- ---------- ---------- ----------
#MinMax constraints ---------- ---------- ----------
AF = []
bF = []
AF = [[0 for i in range(R * m)] for j in range(R)]
for r in range(R):
k = -1
for i in range(n):
for j in range(n):
if (i != j):
k = k + 1
#AF[r][k+r*m] = C[i][j]
#exec('AF[r][k+r*m] = C_%d[i][j]' % r)
AF[r][k + r * m] = C_l[r][i][j] + Csp_l[r][i][j]
bF = [0 for i in range(R)]
#Adding 'F' variable
for k in range(len(AF)):
AF[k].append(-1)
"""
print '\nAF (',len(AF),'x',len(AF[0]),') = '
for k in range(len(AF)):
print AF[k][:]
print '\nsize of AF:', len(AF),'x',len(AF[0])
print '\nbF = ', bF
"""
#---------- ---------- ---------- ---------- ---------- ----------
#Joining all inequality constraints ---------- ---------- ----------
Aineq = []
for line in AF:
Aineq.append(line)
bineq = []
for number in bF:
bineq.append(number)
"""
print '\nAineq (',len(Aineq),'x',len(Aineq[0]),') = '
for k in range(len(Aineq)):
print Aineq[k][:]
print '\nsize of Aineq:', len(Aineq),'x',len(Aineq[0])
print '\nbineq = ', bineq
"""
#---------- ---------- ---------- ---------- ---------- ----------
#Joining all constraints ---------- ---------- ----------
A = []
b = []
#Equality constraints:
for line in Aeq:
A.append(line)
for number in beq:
b.append(number)
#Subtour constraints:
for line in Aineq:
A.append(line)
for number in bineq:
b.append(number)
#---------- ---------- ---------- ---------- ---------- ----------
"""
print '\nA (',len(A),'x',len(A[0]),') = '
for k in range(len(A)):
print A[k][:]
print '\nsize of A:', len(A),'x',len(A[0])
print '\nb = ', b
"""
# Definition of the type of constranis (> < =)
e = []
#Equality constraints (=)
for k in range(len(Aeq)):
e.append(0)
# Inequality constraints (<)
for k in range(len(Aineq)):
e.append(-1)
# ---------- ---------- ----------
# Definition of the integer variables
int_var = range(1, R * m + 1,
1) #???? wouldnt it be range(0, R*m, 1)? No, this is write
#int_var = []
# ---------- ---------- ----------
# Auto scale flag
scalemode = 0
# ---------- ---------- ----------
# Definition of cost function operand (min or max)
setminim = 1
# ---------- ---------- ----------
lp = lp_maker(c, A, b, e, vlb, vub, int_var, scalemode, setminim)
if R == 2:
TIMEOUT = 2.0 * 2 # seconds
else:
TIMEOUT = 3.0 # seconds
TIMEOUT = 60.0
lpsolve('set_timeout', lp, TIMEOUT)
print '\n------------', 'Here is TIMEOUT', TIMEOUT, '------------\n'
print '\nLP problem created'
print 'Nodes:', n
print 'Robots: ', R
print 'Variables:', len(
A[1]), ' (', len(A[1]) - 1, 'integers and', 1, 'real )'
print 'Constraints:', len(A), ' (', len(Aeq), 'equalities and', len(
Aineq), 'inequalities )'
"""
print 'len(Aeq1):', len(Aeq1)
print 'len(Aeq2):', len(Aeq2)
print 'len(Aeq3):', len(Aeq3)
print 'len(Aineq):', len(Aineq)
"""
print ''
print 'LP solution started ...'
t = time.time()
solvestat = lpsolve('solve', lp)
elapsed = time.time() - t
obj = lpsolve('get_objective', lp)
x = lpsolve('get_variables', lp)[0]
lpsolve('delete_lp', lp)
print ''
if (solvestat == 0):
print '----- Optimal solution found -----'
#print '\nX = ', x
print '\nObjective = ', obj
#Print chosen edges
for r in range(R):
chosen = []
for k in range(m):
if (abs(x[r * m + k] - 1) < 10**(-6)):
chosen.append(E[k])
chosen = np.matrix(chosen)
chosen = chosen.T
print('\nChoosen edges for robot %d:' % (r + 1))
print chosen + 1
print ''
for r in range(R):
timeTask = 0
k = -1
for i in range(n):
for j in range(n):
if (i != j):
k = k + 1
if (abs(x[r * m + k] - 1) < 10**(-6)):
#exec ('timeTask = timeTask + C_%d[i][j]' % r)
timeTask = timeTask + C_l[r][i][j]
print('Time task for robot %d: ' %
(r + 1)), timeTask, '(not that correct)'
#print "\n\n----------\n----------\nHere is complete x:\n",x,"----------\n----------\n\n"
else:
print '!!!!! Optimal solution NOT found !!!!!'
print 'Return code', solvestat
if (elapsed < 1):
print '\nElapsed time: ', 1000 * elapsed, 'ms\n'
else:
print '\nElapsed time: ', elapsed, 's\n'
#Plotting results ---------- ---------- ----------
"""
#ZZZpylab.axis('equal')
#ZZZpylab.axis(w_s)
pylab.axis('equal')
pylab.axis(w_s)
for k in range(n):
#pylab.plot(pts[k][0], pts[k][1], 'bo', linewidth=2.0)
#pylab.plot(pts[k][0], pts[k][1], 'b*', linewidth=2.0)
#ZZZpylab.plot(pts[k][0], pts[k][1], 'ko', markersize=10.0)
pylab.plot(pts[k][0], pts[k][1], 'ko', markersize=10.0)
#pylab.text(pts[k][0]+0.04,pts[k][1]+0.04,k+1,fontsize=20.0)
#ZZZpylab.text(pts[k][0] + 0.04, pts[k][1] + 0.04, k + 0, fontsize=20.0)
z = 0
for i in range(n):
for j in range(n):
if(i != j):
#ZZZpylab.plot([pts[i][0],pts[j][0]], [pts[i][1],pts[j][1]],'k--',linewidth=0.2)
pylab.plot([pts[i][0],pts[j][0]], [pts[i][1],pts[j][1]],'k--',linewidth=0.2)
z = 0
for r in range(R):
k = -1
for i in range(n):
for j in range(n):
if (i != j):
k = k + 1
if (abs(x[r * m + k] - 1) < 10 ** (-6)):
#ZZZpylab.plot([pts[i][0],pts[j][0]], [pts[i][1],pts[j][1]],colors[r],linewidth=3.0)
pylab.plot([pts[i][0],pts[j][0]], [pts[i][1],pts[j][1]],colors[r],linewidth=3.0)
z = 0
"""
#write_results_to_file(**locals())
#pylab.show()
#return x, C_check0, C_check1
return x
from lpsolve55 import *
from lp_maker import *
f = [110*1.3, 30*2.0, 125*1.56, 75*1.8, 95*.95, 100*2.25, 50*1.35]
A = [[120, 210, 150.75, 115, 186, 140, 85], [110, 30, 125, 75, 95, 100, 50], [1, 1, 1, 1, 1, 1, 1], [1, -1, 0, 0, 0, 0, 0], [0, 0, 1, 0, -2, 0, 0], [0, 0, 0, -1, 0, -1, 1]]
b = [55000, 40000, 400, 0, 0, 0]
lp = lp_maker(f, A, b, [-1, -1, -1, -1, -1, -1], [10, 10, 10, 10, 20, 20, 20], [100, Infinite, 50, Infinite, Infinite, 250, Infinite], None, 1, 0)
solvestat = lpsolve('solve', lp)
obj = lpsolve('get_objective', lp)
print obj
x = lpsolve('get_variables', lp)[0]
print x
lpsolve('delete_lp', lp)
def formulate_lp(self):
""" Formulates an ILP problem based on given cands and constrs. """
A = []
b = []
e = []
tmpSections = []
for i in self.candidates:
if not i is None:
tmpSections.append(i)
numCands = self.numCands
numSections = len(tmpSections)
totalElems = numSections*numCands
# Template constraint
constr = [0]*numCands*numSections
# print "\t\t\tCreating objective"
# Objective function: minimize sum of ranks
if MIN_RANK:
f = range(1,numCands+1)*numSections
else:
f = []
for i in tmpSections:
f += i.getScores()
# print "\t\t\tOne candidate per section"
# Constraint: Exactly one candidate must be chosen for each section
for j in range(numSections):
A.append([0]*numCands*j + [1]*numCands
+ [0]*numCands*(numSections-j-1))
b.append(1)
e.append(0)
# print "\t\t\tAll pairs similarity"
# Constraint: (x1 + x2) * sim(x1,x2) <= 1
for p1 in range(numCands - 1):
for p2 in range(p1, numCands):
sim = tmpSections[0].sim(tmpSections[0][p1].getID(), tmpSections[0][p2].getID())
index1 = tmpSections[0][p1].getIndex()
index2 = tmpSections[0][p2].getIndex()
index1 = [x for x in index1 if x != -1]
index2 = [x for x in index2 if x != -1]
c = constr[:]
for i in range(numSections):
if not tmpSections[i] is None:
c[i*numCands+index1[i]] = sim
c[i*numCands+index2[i]] = sim
A.append(c)
b.append(1.1)
e.append(-1)
# print "\t\t\tFormulate"
# Minimize or maximize?
obj = 0
if MIN_RANK:
obj = 1
# Get LP formulation (but don't solve yet)
lp = lp_maker(f,A,b,e,None,None,range(1,totalElems+1),1,obj)
return lp
for day in range(0,numberOfDays):
slots = parsedDays[day]["Slots"]
#Create b vector from NumberOfStudents per Slot
b = [None] * len(A)
for slotNumber in range(0, len(A) - 2):
# b[slotNumber] = math.floor(slots[slotNumber]["NumberOfStudents"] / studentsPerTeacher)
b[slotNumber] = math.ceil(slots[slotNumber]["NumberOfStudents"] / studentsPerTeacher)
b[len(A) -2] = fullTimersAvailable
b[len(A) -1] = partTimersAvailable
#Solve model
lp = lp_maker(f, A, b, signs , None, None, None, 1, 0)
solvestat = lpsolve('solve', lp)
obj = lpsolve('get_objective', lp)
x = lpsolve('get_variables', lp)[0]
# print "x = " + str(x)
lpsolve('delete_lp', lp)
# Create full/part time array results
slotsArray = [None] * int(len(A)-2)
for i in range(int(len(A)-2)):
# A[i] is a row of the A array -> an array of 1s, 0s
slot = A[i]
fullCounter = 0
partCounter = 0
def execute_lp(pts, C, cor, PLOT):
n = len(pts)
m = n * (n - 1) #number of edges
w_s = [0, 25, 0, 12.5]
#Definition of the edges
E = [[0 for i in range(2)] for j in range(m)]
k = 0
for i in range(n):
for j in range(n):
if (i != j):
E[k][0] = i
E[k][1] = j
k = k + 1
# ---------- ---------- ----------
#Definition of the cost vector
c = []
for i in range(n):
for j in range(n):
if (i != j):
c.append(C[i][j])
# ---------- ---------- ----------
# "Arival constraints" ---------- ---------- ----------
Aeq1 = [[0 for i in range(m)] for j in range(n)]
count_line = -1
for j in range(n): # 0 until n-1
count_line = count_line + 1
for k in range(m): # 0 until m-1
if (E[k][1] == j):
Aeq1[count_line][k] = 1
beq1 = [1 for i in range(n)]
#---------- ---------- ---------- ---------- ---------- ----------
#"Flux conservation constraints" ---------- ---------- ----------
Aeq2 = [[0 for i in range(m)] for j in range(n)]
for p in range(n): # 0 until n-1
for k in range(0, m): # 0 until m-1
if (E[k][1] == p):
Aeq2[p][k] = 1
if (E[k][0] == p):
Aeq2[p][k] = -1
beq2 = [0 for i in range(n)]
#---------- ---------- ---------- ---------- ---------- ----------
#Joining all equality constraints ---------- ---------- ----------
Aeq = []
Aeq = Aeq + Aeq1 + Aeq2
beq = []
beq = beq + beq1 + beq2
#---------- ---------- ---------- ---------- ---------- ----------
#Definition of the x variables bounds
vlb = []
vub = []
#Bouds of "X" variables
vlb = vlb + [0 for k in range(m)]
vub = vub + [1 for k in range(m)]
# ---------- ---------- ----------
# Definition of the type of constranis (> < =) === (1, -1, 0)
e = []
#Equality constraints (=)
for k in range(len(Aeq)):
e.append(0)
# ---------- ---------- ----------
# Definition of the integer variable
#int_var = range(1, m + 1, 1)
int_var = []
# ---------- ---------- ----------
# Auto scale flag
scalemode = 0
# ---------- ---------- ----------
# Definition of cost function operand (min or max)
setminim = 1
# ---------- ---------- ----------
lp = lp_maker(c, Aeq, beq, e, vlb, vub, int_var, scalemode, setminim)
#TIMEOUT = 1.0 # seconds
#lpsolve('set_timeout', lp, TIMEOUT)
solvestat = lpsolve('solve', lp)
#obj = lpsolve('get_objective', lp)
x = lpsolve('get_variables', lp)[0]
lpsolve('delete_lp', lp)
#PLOT = True
if PLOT:
#Plotting results ---------- ---------- ----------
pylab.axis('equal')
pylab.axis(w_s)
for k in range(n):
pylab.text(pts[k][0] + 0.04,
pts[k][1] + 0.04,
k,
fontsize=10.0,
color=cor)
k = -1
for i in range(n):
for j in range(n):
if (i != j):
k = k + 1
if (abs(x[k] - 1) < 10**(-6)):
pylab.plot([pts[i][0], pts[j][0]],
[pts[i][1], pts[j][1]],
cor + '-',
linewidth=2.0)
#pylab.show()
# ---------- ---------- ---------- ---------- ---------- ----------
if (solvestat == 0):
chosen = []
for k in range(m):
if (abs(x[k] - 1) < 10**(-6)):
chosen.append(E[k])
chosen = np.matrix(chosen)
chosen = chosen.T
else:
chosen = -1
print 'Optimal solution not found'
print 'Here is solvestat: ', solvestat
return (chosen)
def atribute_clusters(speeds, search_speeds, Cost_cluster_len, Cost_cluster_sp,
Cost_cluster_to_go):
R = len(speeds)
T = len(Cost_cluster_len)
print 'Number on robots: ', R, '\nNumber of clusters: ', T
#C = [[r/t for r in Cost_cluster] for t in Power_robot]
#C[r][t] is the cost of r search t
C = [[0 for r in Cost_cluster_len] for t in speeds]
for r in range(R):
for t in range(T):
C[r][t] = Cost_cluster_len[t] / speeds[r] + Cost_cluster_sp[
t] / search_speeds[r] + Cost_cluster_to_go[r][t] / speeds[r]
m = R * T
#Definition of the cost vector
c = []
#Cost of "x" variables
c = c + [0 for k in range(R * T)]
# Cost of "F" variable
c.append(1)
# ---------- ---------- ----------
#Assignment constraints ---------- ---------- ----------
Aeq1 = [[0 for i in range(R * T)] for j in range(T)]
for t in range(T):
for r in range(R):
Aeq1[t][r * T + t] = 1
for k in range(len(Aeq1)):
Aeq1[k].append(0)
beq1 = [1 for i in range(T)]
#---------- ---------- ---------- ---------- ---------- ----------
#MinMax constraints ---------- ---------- ----------
AF = [[0 for i in range(R * T)] for j in range(R)]
for r in range(R):
for t in range(T):
AF[r][r * T + t] = C[r][t]
bF = [0 for r in range(R)]
#Adding 'F' variable
for k in range(len(AF)):
AF[k].append(-1)
#---------- ---------- ---------- ---------- ---------- ----------
Aineq = AF
bineq = bF
Aeq = Aeq1
beq = beq1
#Joining all constraints ---------- ---------- ----------
A = []
b = []
#Inequality constraints:
for line in Aineq:
A.append(line)
for number in bineq:
b.append(number)
#Equality constraints:
for line in Aeq:
A.append(line)
for number in beq:
b.append(number)
#---------- ---------- ---------- ---------- ---------- ----------
#Definition of the x variables bounds
vlb = []
vub = []
#Bouds of "X" variables
vlb = vlb + [0 for k in range(R * T)]
vub = vub + [1 for k in range(R * T)]
# Bouds of "F" variable
vlb.append(0)
vub.append(10000) #big positive number
# ---------- ---------- ----------
# Definition of the type of constranis (> < =)
e = []
# Inequality constraints (<)
for k in range(len(Aineq)):
e.append(-1)
#Equality constraints (=)
for k in range(len(Aeq)):
e.append(0)
# ---------- ---------- ----------
# Definition of the integer variable
int_var = range(1, R * T + 1, 1)
# ---------- ---------- ----------
# Auto scale flag
scalemode = 0
# ---------- ---------- ----------
# Definition of cost function operand (min or max)
setminim = 1
# ---------- ---------- ----------
lp = lp_maker(c, A, b, e, vlb, vub, int_var, scalemode, setminim)
solvestat = lpsolve('solve', lp)
#obj = lpsolve('get_objective', lp)
x = lpsolve('get_variables', lp)[0]
lpsolve('delete_lp', lp)
return x
def solveIt(inputData):
# Modify this code to run your optimization algorithm
# parse the input
lines = inputData.split('\n')
firstLine = lines[0].split()
nodeCount = int(firstLine[0])
edgeCount = int(firstLine[1])
edges = []
for i in range(1, edgeCount + 1):
line = lines[i]
parts = line.split()
edges.append((int(parts[0]), int(parts[1])))
# build a trivial solution
# every node has its own color
#items = len(values)
#define n constraints fir each possible color:
maxNumColors=20#int(math.floor(nodeCount//4))
#overall number of variables= numNodes+numEdges
c=([1]*maxNumColors)+([0]*(maxNumColors*nodeCount))
lower=[0]*len(c)
upper=[1]*len(c)
intIndices=range(1,len(c)+1)
b=[]
e=[]
#each node is colored with one color:
A=[[0]*maxNumColors*(i+1)+[1]*maxNumColors+[0]*maxNumColors*(nodeCount-i-1) for i in range(nodeCount)]#total number of variabes=(maxnumcols)*(nodecount+1)
b.append([1]*len(A))
e.append([0]*len(A))#equality constraints
# xik-yi<=0- that these are nodeCount*nodeCount constraints
for nd in range(nodeCount):
for col in range(maxNumColors):
cons=[0]*len(c)
cons[col]=-1
cons[maxNumColors*(nd+1)+col]=1
A.append(cons)
e.append([-1]*(nodeCount*maxNumColors))
b.append([0]*(nodeCount*maxNumColors))
# the third constraind- one for each edge and each k
#smaller than 1
for ed in edges:
for col in range(maxNumColors):
cons=[0]*len(c)
cons[(ed[0]+1)*maxNumColors+col]=1
cons[(ed[1]+1)*maxNumColors+col]=1
A.append(cons)
e.append([-1]*(maxNumColors*edgeCount))
b.append([1]*(maxNumColors*edgeCount))
# #smaller than 1
# for ed in edges:
# for col in range(nodeCount):
# cons=[0]*len(c)
# cons[ed[0]*(nodeCount+1)+col]=1
# cons[ed[1]*(nodeCount+1)+col]=1
# A.append(cons)
# e.append([-1]*(nodeCount*edgeCount))
# b.append([1]*(nodeCount*edgeCount))
#
# #larger than 0
# for ed in edges:
# for col in range(nodeCount):
# cons=[0]*len(c)
# cons[ed[0]*(nodeCount+1)+col]=1
# cons[ed[1]*(nodeCount+1)+col]=1
# A.append(cons)
# e.append([1]*(nodeCount*edgeCount))
# b.append([0]*(nodeCount*edgeCount))
#constraints 5 and 6 are in upper, lower and intIndices
# a trivial greedy algorithm for filling the knapsack
# it takes items in-order until the knapsack is full
b = [val for subl in b for val in subl]
e = [val for subl in e for val in subl]
lp=lp_maker(c, A, b, e, lower, upper,intIndices,setminim=1)
lpsolve('set_timeout',lp,600)
lpsolve('solve', lp)
obj=lpsolve('get_objective', lp)
#print(c)
#print(obj)
x=lpsolve('get_variables', lp)[0]
flag=lpsolve('get_variables', lp)[1]
lpsolve('delete_lp', lp)
# print(x)
# for k in range(nodeCount):
# print(x[((k+1)*nodeCount):((k+2)*(nodeCount))])
print(nodeCount,maxNumColors)
print(sum(x[:maxNumColors]))
solution = [x[((node+1)*maxNumColors):((node+2)*(maxNumColors))].index(1)+1 for node in range(nodeCount)]
sList=sorted(solution)
sList.sort()
d={}
for i in sList:
if(i in d.keys()):
continue
else:
d[i]=len(d.keys())
solution=map(lambda x:d[x],solution)
objFunction=x
# prepare the solution in the specified output format
outputData = str(int(obj)) + ' ' + str(int(flag)) + '\n'
outputData += ' '.join(map(lambda x:str(int(x)), solution))
return outputData
def ec2(request):
'''
min aikenuoyan + heizheshi + huiyan + keluojishi + shuangduoteshi + pianmayan
aikenuoyan = 22000santaihejin + 2500leiyin + 320chaoshikuang 28367
heizheshi = 10000santaihejin + 1600tongweijuheti + 120chaoxinxing 28394
huiyan = 56000santaihejin + 450tongweijuheti + 12050leijingti + 2100leiyin 28420
keluojishi = 21000santaihejin + 135jingzhuangshiying + 760chaoxinxing 28391
shuangduoteshi = 450jingzhuangshiying +12000leijingti 28388
pianmayan = 300tongweijuheti + 2200leijingti + 2400leiyin 28397
22000aikenuoyan + 10000heizheshi + 56000huiyan + 2100keluojishi >=
1600heizheshi + 450huiyan + 300pianmayan >=
135keluojishi + 450shuangduoteshi >=
12050huiyan + 12000shuangduoteshi + 2200pianmayan >=
2500aikenuoyan + 2100huiyan + 2400pianmayan >=
320aikenuoyan + 100shuangduoteshi >=
120heizheshi + 760keluojishi >=
'''
request.encoding = 'utf-8'
#获取前端选择的参与计算的矿石checkbox拼接字符串
kuangs = request.POST['kuang']
kl1 = [int(x) for x in kuangs.split(",")]
kuangname = [
"希莫非特Hemorphite", "水硼砂Kernite", "奥贝尔石Omber", "斜长岩Plagioclase",
"干焦岩Pyroxeres", "灼烧岩Scordite", "凡晶石Veldspar", "同位原矿Hedbergite",
"杰斯贝矿Jaspet", "艾克诺岩Arkonor", "黑赭石Dark Ochre", "灰岩Spodumain",
"克洛基石Crokite", "双多特石Bistot", "片麻岩Gneiss"
]
kuanglian = {
"希莫非特Hemorphite": [2200, 100, 15, 0, 0, 0, 120],
"水硼砂Kernite": [134, 134, 0, 0, 267, 0, 0],
"奥贝尔石Omber": [800, 85, 0, 100, 0, 0, 0],
"斜长岩Plagioclase": [107, 0, 0, 213, 107, 0, 0],
"干焦岩Pyroxeres": [351, 0, 0, 25, 50, 0, 5],
"灼烧岩Scordite": [346, 0, 0, 173, 0, 0, 0],
"凡晶石Veldspar": [415, 0, 0, 0, 0, 0, 0],
"同位原矿Hedbergite": [0, 200, 19, 1000, 0, 0, 100],
"杰斯贝矿Jaspet": [0, 0, 8, 0, 350, 0, 75],
"艾克诺岩Arkonor": [22000, 0, 0, 0, 2500, 320, 0],
"黑赭石Dark Ochre": [10000, 1600, 0, 0, 0, 0, 120],
"灰岩Spodumain": [56000, 450, 0, 12050, 2100, 0, 0],
"克洛基石Crokite": [21000, 0, 135, 0, 0, 0, 750],
"双多特石Bistot": [0, 0, 450, 12000, 0, 100, 0],
"片麻岩Gneiss": [0, 300, 0, 2200, 2400, 0, 0]
}
kuanglianlist = []
for i in kuangname:
kuanglianlist.append(kuanglian[i])
kl2 = [] #用来获取各个所需矿石的精炼列表
for i in kl1:
kl2.append(kuanglian[kuangname[i]])
daijinglian = [[], [], [], [], [], [], []]
for i in range(0, 7):
for j in kl2:
daijinglian[i].append(j[i])
print(daijinglian)
#这里需要改成xx key and xx key
kuangpricelist = []
kuangidlist = [
28403, 28410, 28416, 28422, 28424, 28429, 28432, 28401, 28406, 28367,
28394, 28420, 28391, 28388, 28397
]
kuangpricelistall = [
'', '', '', '', '', '', '', '', '', '', '', '', '', '', ''
]
for i in kl1:
is_cache = cache.get(kuangname[i])
if (is_cache):
kuangpricelist.append(is_cache)
kuangpricelistall[i] = is_cache
else:
req_url = 'https://api.evemarketer.com/ec/marketstat/json?typeid=' + str(
kuangidlist[i]) + '®ionlimit=10000002'
req = requests.get(req_url) #发送请求
rt = req.text #获取响应信息
itemPriceInfo = json.loads(rt) #将JSON str转换为原格式，此处为list格式
itemBuy = itemPriceInfo[0]['buy']['max'] #获取jita buy最高价
kuangpricelist.append(itemBuy)
cache.set(kuangname[i], itemBuy, 600)
kuangpricelistall[i] = itemBuy
print(kuangpricelist)
'''
n_santaihejin = 774565133
n_tongweijuheti = 10489443
n_jingzhuangshiying = 1091619
n_leijingti = 183660168
n_leiyin = 72099790
n_chaoshikuang = 431586
n_chaoxinxing = 2951669
'''
n_santaihejin = int(request.POST['santai'])
n_tongweijuheti = int(request.POST['tongwei'])
n_jingzhuangshiying = int(request.POST['jingzhuang'])
n_leijingti = int(request.POST['leijing'])
n_leiyin = int(request.POST['leiyin'])
n_chaoshikuang = int(request.POST['chaoshi'])
n_chaoxinxing = int(request.POST['chaoxin'])
#获取到输入的矿物需求，接下来加上旗舰组件的数据
#旗舰组件矿数量
qj0 = ['457050', '6938', '604', '110416', '41994', '302', '2110']
qj1 = ['546912', '7760', '876', '113826', '45010', '386', '2358']
qj2 = ['443591', '6659', '666', '101026', '40877', '298', '1804']
qj3 = ['473141', '7109', '682', '111118', '43324', '304', '2141']
qj4 = ['326973', '6440', '660', '107842', '39547', '280', '1841']
qj5 = ['510149', '7491', '728', '110413', '45621', '334', '2191']
qj6 = ['498880', '7269', '696', '104957', '43194', '332', '2033']
qj7 = ['749916', '8617', '908', '142710', '49913', '444', '2249']
qj8 = ['347163', '4499', '486', '83248', '33332', '172', '1258']
qj9 = ['427708', '6581', '648', '111110', '44110', '296', '1858']
qj10 = ['388208', '5104', '538', '93777', '37729', '212', '1530']
qj11 = ['1121659', '17669', '1488', '278776', '75379', '1134', '4176']
qj12 = ['640393', '8888', '1082', '139591', '48471', '444', '2612']
qj13 = ['841877', '11132', '1108', '207776', '61980', '572', '3317']
qj14 = ['555658', '7916', '908', '125277', '47249', '428', '2438']
qj15 = ['576759', '9010', '914', '189942', '53312', '416', '2461']
qj16 = ['583442', '9321', '938', '145664', '51297', '436', '2678']
qj17 = ['874902', '3504', '286', '72154', '24616', '64', '998']
qjksl = [
qj0, qj1, qj2, qj3, qj4, qj5, qj6, qj7, qj8, qj9, qj10, qj11, qj12,
qj13, qj14, qj15, qj16, qj17
]
#旗舰组件所需数量
q0 = int(request.POST['qj0'])
q1 = int(request.POST['qj1'])
q2 = int(request.POST['qj2'])
q3 = int(request.POST['qj3'])
q4 = int(request.POST['qj4'])
q5 = int(request.POST['qj5'])
q6 = int(request.POST['qj6'])
q7 = int(request.POST['qj7'])
q8 = int(request.POST['qj8'])
q9 = int(request.POST['qj9'])
q10 = int(request.POST['qj10'])
q11 = int(request.POST['qj11'])
q12 = int(request.POST['qj12'])
q13 = int(request.POST['qj13'])
q14 = int(request.POST['qj14'])
q15 = int(request.POST['qj15'])
q16 = int(request.POST['qj16'])
q17 = int(request.POST['qj17'])
qjsl = [
q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, q10, q11, q12, q13, q14, q15,
q16, q17
]
#旗舰需要的矿物先清零
qn_santaihejin = 0
qn_tongweijuheti = 0
qn_jingzhuangshiying = 0
qn_leijingti = 0
qn_leiyin = 0
qn_chaoshikuang = 0
qn_chaoxinxing = 0
for i in range(0, 18):
qn_santaihejin = qn_santaihejin + int(qjksl[i][0]) * int(qjsl[i])
qn_tongweijuheti = qn_tongweijuheti + int(qjksl[i][1]) * int(qjsl[i])
qn_jingzhuangshiying = qn_jingzhuangshiying + int(qjksl[i][2]) * int(
qjsl[i])
qn_leijingti = qn_leijingti + int(qjksl[i][3]) * int(qjsl[i])
qn_leiyin = qn_leiyin + int(qjksl[i][4]) * int(qjsl[i])
qn_chaoshikuang = qn_chaoshikuang + int(qjksl[i][5]) * int(qjsl[i])
qn_chaoxinxing = qn_chaoxinxing + int(qjksl[i][6]) * int(qjsl[i])
#加上旗舰组件之后，目前n_为未减免前所有需要的矿物
#接下来计算图纸和建筑插、建筑减免
tuzhicailiao = int(request.POST['tuzhicailiao'])
jianzhucha = float(request.POST['jianzhucha'])
jianzhu = int(request.POST['jianzhu'])
#计算出最终旗舰减免
jianmian = (100 - tuzhicailiao) / 100 * (100 - jianzhu) / 100 * (
100 - jianzhucha) / 100
qn_santaihejin = math.ceil(qn_santaihejin * jianmian)
qn_tongweijuheti = math.ceil(qn_tongweijuheti * jianmian)
qn_jingzhuangshiying = math.ceil(qn_jingzhuangshiying * jianmian)
qn_leijingti = math.ceil(qn_leijingti * jianmian)
qn_leiyin = math.ceil(qn_leiyin * jianmian)
qn_chaoshikuang = math.ceil(qn_chaoshikuang * jianmian)
qn_chaoxinxing = math.ceil(qn_chaoxinxing * jianmian)
#通过精炼率计算出化矿产物
jinglianlv = float(request.POST['jinglianlv']) / 100
#减去已有的矿石数量
hk0 = int(request.POST['h_kuang0'])
hk1 = int(request.POST['h_kuang1'])
hk2 = int(request.POST['h_kuang2'])
hk3 = int(request.POST['h_kuang3'])
hk4 = int(request.POST['h_kuang4'])
hk5 = int(request.POST['h_kuang5'])
hk6 = int(request.POST['h_kuang6'])
hk7 = int(request.POST['h_kuang7'])
hk8 = int(request.POST['h_kuang8'])
hk9 = int(request.POST['h_kuang9'])
hk10 = int(request.POST['h_kuang10'])
hk11 = int(request.POST['h_kuang11'])
hk12 = int(request.POST['h_kuang12'])
hk13 = int(request.POST['h_kuang13'])
hk14 = int(request.POST['h_kuang14'])
havekuanglist = [
hk0, hk1, hk2, hk3, hk4, hk5, hk6, hk7, hk8, hk9, hk10, hk11, hk12,
hk13, hk14
]
h_santaihejin = 0
h_tongweijuheti = 0
h_jingzhuangshiying = 0
h_leijingti = 0
h_leiyin = 0
h_chaoshikuang = 0
h_chaoxinxing = 0
for i in range(0, 15):
h_santaihejin = h_santaihejin + math.floor(
havekuanglist[i] * kuanglianlist[i][0] * jinglianlv)
h_tongweijuheti = h_tongweijuheti + math.floor(
havekuanglist[i] * kuanglianlist[i][1] * jinglianlv)
h_jingzhuangshiying = h_jingzhuangshiying + math.floor(
havekuanglist[i] * kuanglianlist[i][2] * jinglianlv)
h_leijingti = h_leijingti + math.floor(
havekuanglist[i] * kuanglianlist[i][3] * jinglianlv)
h_leiyin = h_leiyin + math.floor(
havekuanglist[i] * kuanglianlist[i][4] * jinglianlv)
h_chaoshikuang = h_chaoshikuang + math.floor(
havekuanglist[i] * kuanglianlist[i][5] * jinglianlv)
h_chaoxinxing = h_chaoxinxing + math.floor(
havekuanglist[i] * kuanglianlist[i][6] * jinglianlv)
#至此得到最终所需矿物
n_santaihejin = n_santaihejin + qn_santaihejin - h_santaihejin
n_tongweijuheti = n_tongweijuheti + qn_tongweijuheti - h_tongweijuheti
n_jingzhuangshiying = n_jingzhuangshiying + qn_jingzhuangshiying - h_jingzhuangshiying
n_leijingti = n_leijingti + qn_leijingti - h_leijingti
n_leiyin = n_leiyin + qn_leiyin - h_leiyin
n_chaoshikuang = n_chaoshikuang + qn_chaoshikuang - h_chaoshikuang
n_chaoxinxing = n_chaoxinxing + qn_chaoxinxing - h_chaoxinxing
A = [[], [], [], [], [], [], []]
#A在最开始获取选取的矿石时已定义
for i in range(len(daijinglian)):
for j in range(len(daijinglian[i])):
A[i].append(math.floor(daijinglian[i][j] * jinglianlv))
print(A)
l = []
for i in range(len(kl1)):
l.append(0)
#以最少花费计算
f = kuangpricelist
#以最少矿石数量计算
#f=[1,1,1,1,1,1]
#列表A在上面的精炼计算区域已经定义了
#A=[[22000,10000,56000,2100,0,0],[0,1600,450,0,0,300],[0,0,0,135,450,0],[0,0,12050,0,12000,2200],[2500,0,2100,0,0,2400],[320,0,0,0,100,0],[0,120,0,760,0,0]]
b = [
n_santaihejin, n_tongweijuheti, n_jingzhuangshiying, n_leijingti,
n_leiyin, n_chaoshikuang, n_chaoxinxing
]
e = [1, 1, 1, 1, 1, 1, 1] #全大于
#l=[0,0,0,0,0,0]#最小值
lp = lp_maker(f, A, b, [1, 1, 1, 1, 1, 1, 1], l, None, None, 1, 1)
#set_int(lp,1,TRUE)
solvestat = lpsolve('solve', lp)
y = lpsolve('get_variables', lp)[0]
x = []
if (isinstance(y, list)):
x = y
else:
x.append(y)
print(x)
#将规划好的数据向上取整，得到各高密度矿石数量
for i in range(len(x)):
x[i] = math.ceil(x[i])
#这个answer变量好像没用上，本意是最终所有矿石的结果和所有矿石的价格表遍历相乘，但是后来使用了最终结果的x列表和指定矿石的价格。
answer = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
for i in range(len(kl1)):
answer[kl1[i]] = int(x[i])
'''
#这里获取输入的已有矿石数量，要求格式：名字-数量-组
tas="""三晶双多特斜岩 79 双多特石
三钛合金 52 矿物
三钛合金 7,064,097 矿物"""
tasp=tas.split("\n")
print(tasp)
tasd={}
for i in range(len(tasp)):
tasp[i]=tasp[i].split("\t")
tasp[i]=tasp[i][1:3]
tasp[i]=tasp[i][::-1]
print(tasp[i])
key = tasp[i][0]
if key in tasd:
tasd[key]+=int(tasp[i][1].replace(',',''))
else:
tasd[key]=int(tasp[i][1].replace(',',''))
print(tasd)
if '艾克诺岩' in tasd:
x[0]=x[0]-tasd['艾克诺岩']
if '黑赭石' in tasd:
x[1]=x[1]-tasd['黑赭石']
if '灰岩' in tasd:
x[2]=x[2]-tasd['灰岩']
if '克洛基石' in tasd:
x[3]=x[3]-tasd['克洛基石']
if '双多特石' in tasd:
x[4]=x[4]-tasd['双多特石']
if '片麻岩' in tasd:
x[5]=x[5]-tasd['片麻岩']
#这里算好最后需要的矿石数量
'''
#f_ = h_ + anwser[]
f_santaihejin = h_santaihejin
f_tongweijuheti = h_tongweijuheti
f_jingzhuangshiying = h_jingzhuangshiying
f_leijingti = h_leijingti
f_leiyin = h_leiyin
f_chaoshikuang = h_chaoshikuang
f_chaoxinxing = h_chaoxinxing
for i in range(0, 15):
f_santaihejin = f_santaihejin + math.floor(
answer[i] * kuanglianlist[i][0] * jinglianlv)
f_tongweijuheti = f_tongweijuheti + math.floor(
answer[i] * kuanglianlist[i][1] * jinglianlv)
f_jingzhuangshiying = f_jingzhuangshiying + math.floor(
answer[i] * kuanglianlist[i][2] * jinglianlv)
f_leijingti = f_leijingti + math.floor(
answer[i] * kuanglianlist[i][3] * jinglianlv)
f_leiyin = f_leiyin + math.floor(
answer[i] * kuanglianlist[i][4] * jinglianlv)
f_chaoshikuang = f_chaoshikuang + math.floor(
answer[i] * kuanglianlist[i][5] * jinglianlv)
f_chaoxinxing = f_chaoxinxing + math.floor(
answer[i] * kuanglianlist[i][6] * jinglianlv)
cost = 0
for i in range(len(kuangpricelist)):
#cost = cost + answer[i]*kuangpricelist[i]
cost = cost + x[i] * kuangpricelist[i]
context = {}
#名字数组kuangname，answer,havekuanglist,kuangpricelistall
context["kuang"] = list(
zip(kuangname, answer, havekuanglist, kuangpricelistall))
context['cost'] = format(cost, ',')
context['n_santai'] = n_santaihejin
context['n_tongwei'] = n_tongweijuheti
context['n_jingzhuang'] = n_jingzhuangshiying
context['n_leijing'] = n_leijingti
context['n_leiyin'] = n_leiyin
context['n_chaoshi'] = n_chaoshikuang
context['n_chaoxin'] = n_chaoxinxing
context['f_santai'] = f_santaihejin
context['f_tongwei'] = f_tongweijuheti
context['f_jingzhuang'] = f_jingzhuangshiying
context['f_leijing'] = f_leijingti
context['f_leiyin'] = f_leiyin
context['f_chaoshi'] = f_chaoshikuang
context['f_chaoxin'] = f_chaoxinxing
context['m_santai'] = f_santaihejin - n_santaihejin
context['m_tongwei'] = f_tongweijuheti - n_tongweijuheti
context['m_jingzhuang'] = f_jingzhuangshiying - n_jingzhuangshiying
context['m_leijing'] = f_leijingti - n_leijingti
context['m_leiyin'] = f_leiyin - n_leiyin
context['m_chaoshi'] = f_chaoshikuang - n_chaoshikuang
context['m_chaoxin'] = f_chaoxinxing - n_chaoxinxing
return render(request, 'ec2.html', context)
