class BNode:
def __init__(self, value):
self.left = None
self.right = None
self.parent = None
self.value = value
def cut(actual):
# single leaf
if actual.left is None and actual.right is None:
return float("inf")
# actual Node has single child
elif actual.left is not None and actual.right is None:
return min(actual.value, cut(actual.left))
elif actual.right is not None and actual.left is None:
return min(actual.value, cut(actual.right))
# two children on actual level
else:
return min(actual.value, cut(actual.left) + cut(actual.right))
def cutthetree(T):
# cannot use root value so, i made another recustion function to calculate best option
return cut(T.left) + cut(T.right)
runtests(cutthetree)
return tabCP
def opt_sum(tab):
if len(tab) == 1: #przypadek bazowy - sprawdzamy wynik końcowy
return tab[0]
# lowestAbsolute - największy wynik tymczasowy; ansInd - indeks pierwszego z dwóch elementów, który ten wynik tworzy.
# Na poczatek zakładamy, że to pierwsza para elementów jest tą, którą szukamy
lowestAbsolute = abs(tab[0] + tab[1])
ansInd = 0
#przeszukiwanie tablicy w poszukiwaniu najmniejszej wartości bezwzględnej
for i in range(1, len(tab) - 1):
tmp = abs(tab[i]+tab[i+1])
if tmp < lowestAbsolute:
lowestAbsolute = tmp
ansInd = i
# przygotowanie tablicy po dodaniu dwóch elementów o najmniejszej wartości bezwzględnej po zsumowaniu
prepTab = prepTabCopy(tab, ansInd)
# sprawdzamy rekurencyjnie, czy pozostałe dodawania nie mają większej wartości tymczasowej
# max(a1,a2,a3...) = max(a1, max(a2, max(a3,...)))
return max(lowestAbsolute, opt_sum(prepTab))
runtests( opt_sum )
return best
def valuable_tree(T, k):
global cache_k
cache_k = k
return g(T, k)
if __name__ == "__main__":
A = Node()
B = Node()
C = Node()
D = Node()
E = Node()
F = Node()
G = Node()
set_left(A, B, 1)
set_right(A, E, 5)
set_left(B, D, 6)
set_right(B, C, 2)
set_left(C, F, 8)
set_right(C, G, 10)
print(valuable_tree(A, 3))
runtests(valuable_tree)
d = [[[[inf for s in range(N_SPEEDS)] for r in range(N_ROTS)] for y in range(h)] for x in range(w)]
visited = [[[[False for s in range(N_SPEEDS)] for r in range(N_ROTS)] for y in range(h)] for x in range(w)]
Q = PriorityQueue()
d[A[0]][A[1]][0][0] = 0
Q.put((0, (A[0], A[1], 0, 0)))
while not Q.empty():
_, state = Q.get()
x, y, r, s = state
if visited[x][y][r][s]:
continue
visited[x][y][r][s] = True
for (new_state, cost) in G[x][y][r][s]:
nx, ny, nr, ns = new_state
if d[x][y][r][s] + cost < d[nx][ny][nr][ns]:
d[nx][ny][nr][ns] = d[x][y][r][s] + cost
Q.put((d[nx][ny][nr][ns], (nx, ny, nr, ns)))
best_cost = inf
for r in range(N_ROTS):
for s in range(N_SPEEDS):
best_cost = min(best_cost, d[B[0]][B[1]][r][s])
return None if isinf(best_cost) else best_cost
runtests(robot)
from zad2testy import runtests
def fast_list_prepend(L, a):
# tu prosze wpisac wlasna implementacje
return FastListNode(a)
class FastListNode:
def __init__(self, a):
self.a = a # przechowywana liczba calkowita
self.next = [
] # lista odnosnikow do innych elementow; poczatkowo pusta
def __str__(self): # zwraca zawartosc wezla w postaci napisu
res = 'a: ' + str(self.a) + '\t' + 'next keys: '
res += str([n.a for n in self.next])
return res
runtests(fast_list_prepend)