def weight(self, Q: "int") -> "Real":
memlen = min(Q, max(self.v)) + 1
mem = [0] * memlen
for q in range(1, Q + 1):
mem[q % memlen] = min((mem[(q - self.v[i]) % memlen] + self.w[i]
for i in range(self.n) if self.v[i] <= q),
ifempty=infinity)
return mem[Q % memlen] #]class
def some_to_some_distance(self, G: "acyclic IDigraph<T>", d: "T, T -> R",
I: "SizedIterableContainer<T>", F: "SizedIterableContainer<T>") -> "R":
D = self.createMap(G.V)
for v in G.V: D[v] = infinity
for s in I: D[s] = 0
for _ in range(len(G.V)-1):
for v in G.V:
D[v] = min(D[v], min((D[u] + d(u,v) for u in G.preds(v)), ifempty=infinity))
return min(D[t] for t in F) #]bellmanford
def distance(self, G: "Digraph<T>", d: "T, T -> R", I: "ISet<T>",
F: "ISet<T>", k: "int") -> "R":
D = self.createMap(G.V, k)
for v in G.V:
D[v, 0] = infinity
for s in I:
D[s, 0] = 0
for i in range(1, k + 1):
for v in G.V:
D[v, i] = min((D[u, i - 1] + d(u, v) for u in G.preds(v)),
ifempty=infinity)
return min(D[t, k] for t in F) #]kedges
def weight(self, Q):
L = self.createMap()
for q in range(1, Q + 1):
L[q, 0] = infinity
L[0, 0] = 0
for n in range(1, self.n + 1):
for q in range(Q + 1):
L[q, n] = min(
(L[q - i * self.v[n - 1], n - 1] + i * self.w[n - 1]
for i in range(
min(q // self.v[n - 1] + 1, self.m[n - 1] + 1))),
ifempty=infinity)
return L[Q, self.n] #]class
def distance(self, G: "Digraph<T>", d: "T, T -> R", I: "ISet<T>",
F: "ISet<T>", k: "int") -> "R":
prev, curr = self.createMap(G.V), self.createMap(G.V)
for v in G.V:
curr[v] = infinity
for s in I:
curr[s] = 0
for _ in range(1, k + 1):
prev, curr = curr, prev
for v in G.V:
curr[v] = min((prev[u] + d(u, v) for u in G.preds(v)),
ifempty=infinity)
return min(curr[t] for t in F) #]kedges2
def some_to_some_distance(self, G: "acyclic IDigraph<T>", d: "T, T -> R",
I: "SizedIterableContainer<T>", F: "SizedIterableContainer<T>") -> "R":
mindist = infinity
mem = self.createMap(G.V)
left = len(F)
for v in self.createTopsorter(G).topsorted(G):
if left == 0: break
mem[v] = min(0 if v in I else infinity,
min((mem[u] + d(u,v) for u in G.preds(v)), ifempty=infinity))
if v in F:
if mem[v] < mindist: mindist = mem[v]
left -= 1
return mindist #]iter
def L(q):
if q == 0: return 0
for i in range(self.n):
if self.v[i] <= q and q - self.v[i] not in mem:
mem[q - self.v[i]] = L(q - self.v[i])
return min((mem[q - self.v[i]] + self.w[i]
for i in range(self.n) if self.v[i] <= q),
ifempty=infinity)
def weight(self, Q: "int") -> "Real":
current = [0] + [infinity] * Q
previous = [None] * (Q + 1)
for n in range(1, self.n + 1):
previous, current = current, previous
for q in range(Q + 1):
current[q] = min((previous[q-i*self.v[n-1]] + i*self.w[n-1] \
for i in range(q//self.v[n-1]+1)), ifempty=infinity)
return current[Q] #]class
def __init__(self, s=None, v=None, G=None, w=None):
_StateBase.__init__(self, s, sample(G.V, 1)[0] if v == None else v)
if s == None: self.known = 0
else: self.known = s.known + w(s.v, v)
unvisited = set(G.V) - self.visited()
departures = unvisited.union([v]) if v != None else unvisited
arrivals = unvisited.union([self.head()])
unknown = sum(min((w(u,v_prime) for v_prime in G.succs(u) if v_prime in arrivals), ifempty=infinity)\
for u in departures)
self.score = self.known + unknown
def some_to_some_distance(self, G: "acyclic IDigraph<T>", d: "T, T -> R",
I: "SizedIterableContainer<T>",
F: "SizedIterableContainer<T>") -> "R":
def D(v):
init = 0 if v in I else infinity
return min(
init,
min((D(u) + d(u, v) for u in G.preds(v)), ifempty=infinity))
return min(D(v) for v in F) #]recdag
def some_to_some_distance(self, G: "acyclic IDigraph<T>", d: "T, T -> R",
I: "SizedIterableContainer<T>",
F: "SizedIterableContainer<T>") -> "R":
mindist = infinity
mem = self.createMap(G.V)
left = len(F)
for v in self.createTopsorter(G).topsorted(G):
if left == 0: break
memv = mem[v] if v in mem else infinity
if v in I:
memv = min(0, mem[v])
if v in F:
if memv < mindist: mindist = memv
left -= 1
if left > 0:
del mem[v]
for w in G.succs(v):
if w not in mem: mem[w] = infinity
mem[w] = min(mem[w], memv + d(v, w))
return mindist #]iter
def some_to_some_distance(self, G: "acyclic IDigraph<T>",
d: "T, T -> R", I: "ICollection<T>", F: "ICollection<T>") -> "R":
mem = self.createMap(G.V)
def D(v):
init = 0 if v in I else infinity
for u in G.preds(v):
if u not in mem: mem[u] = D(u)
return min(init, min((mem[u] + d(u,v) for u in G.preds(v)), ifempty=infinity))
for t in F:
if t not in mem: mem[t] = D(t)
return min(mem[t] for t in F) #]memo
def weight(self, Q: "int") -> "Real":
mem = self.createMap()
mem[0, 0] = 0
for q in range(1, Q + 1):
mem[q, 0] = infinity
for n in range(1, self.n + 1):
mem[0, n] = 0
for q in range(1, Q + 1):
mem[q, n] = min((mem[q-i*self.v[n-1],n-1]+i*self.w[n-1] \
for i in range(q // self.v[n-1]+1)), ifempty=infinity)
return mem[Q, self.n] #]class
def weight(self, Q: "int") -> "Real":
memlen = max(self.maxmem, Q)
mem = [None] * memlen
mem[0] = 0
for q in range(1, Q + 1):
mem[q % memlen] = min((mem[(q - self.v[i]) % memlen] + self.w[i]
for i in range(self.n) if self.v[i] <= q),
ifempty=infinity)
return mem[Q % memlen] #]class
#]cl
def L(q: "int") -> "Real":
if q == 0: return 0
return min((L(q - self.v[i]) + self.w[i]
for i in range(self.n) if self.v[i] <= q),
ifempty=infinity)
def D(v):
init = 0 if v in I else infinity
for u in G.preds(v):
if u not in mem: mem[u] = D(u)
return min(init, min((mem[u] + d(u,v) for u in G.preds(v)), ifempty=infinity))
def __init__(self, G, w):
TspAsBranchAndBoundProblem2.__init__(self, G, w)
self.best_departure = dict((u, min((w(u,v) for v in G.succs(u)), ifempty=infinity))\
for u in G.V)
def opt(self, a, b):
return min(a, b)
def testMin(self):
self.assertEqual(min(1, 2, 3, 4), 1)
self.assertEqual(min([1]), 1)
self.assertEqual(min([], ifempty=123), 123)
self.assertRaises(ValueError, min, [])
def weight(self, Q: "int") -> "Real":
mem = [0] + [None] * Q
for q in range(1, Q+1):
mem[q] = min((mem[q-self.v[i]] + self.w[i] for i in range(self.n) if self.v[i] <= q),
ifempty=infinity)
return mem[Q]#]class
def D(v):
init = 0 if v in I else infinity
return min(
init,
min((D(u) + d(u, v) for u in G.preds(v)), ifempty=infinity))
