distances[s] = 0
parents = [-1] * len(G)
bfs(G, visited, distances, parents, s)
dist = distances[t]
if dist == inf:
return None
vertices = []
i = t
while parents[i] != -1:
vertices.append((parents[i], i))
i = parents[i]
for vertex in vertices:
G[vertex[0]].remove(vertex[1], )
G[vertex[1]].remove(vertex[0], )
for i in range(len(G)):
visited[i] = False
distances[i] = inf
parents[i] = -1
visited[s] = True
distances[s] = 0
bfs(G, visited, distances, parents, s)
new_dist = distances[t]
if new_dist > dist:
return vertex
G[vertex[0]].append(vertex[1])
G[vertex[1]].append(vertex[0])
return None
runtests(enlarge)
# Labirynt. Labirynt reprezentowany jest przez tablicę w wierszy, z których każdy jest napisem
# składającym się z k kolumn. Pusty znak oznacza pole po którym robot może się poruszać, a znak ’X’
# oznacza ścianę labiryntu. Labirynt zawsze otoczony jest ścianami i nie da się opuścić planszy.
# Pozycja robota. Początkowo robot znajduje się na pozycji A = (x[a], y[a]) i jest obrócony w prawo
# (tj. znajduje się w wierszu y[a] i kolumnie x[a], skierowany w stronę rosnących numerów kolumn).
from Exercise_2_tests import runtests
from queue import PriorityQueue
def robot(L, A, B):
DP = [[[[-1] * 3 for _ in range(4)] for _ in range(len(L[0]))] for _ in range(len(L))]
queue = PriorityQueue()
queue.put((0, A[0], A[1], 0, 0))
possible_moves = [(1, 0), (0, 1), (-1, 0), (0, -1)]
seconds = [60, 40, 30]
while not queue.empty():
time, x, y, direction, idx = queue.get()
if (x, y) == B:
return time
if DP[y][x][direction][idx] != -1 or L[y][x] == 'X':
continue
DP[y][x][direction][idx] = time
queue.put((time + 45, x, y, (direction + 1) % 4, 0))
queue.put((time + 45, x, y, (direction + 3) % 4, 0))
x += possible_moves[direction][0]
y += possible_moves[direction][1]
queue.put((time + seconds[idx], x, y, direction, min(idx + 1, 2)))
runtests(robot)
u = queue.get()
for v in range(len(graph)):
if not visited[v] and graph[u][v] == 1:
queue.put(v)
visited[v] = True
result[v] = count
return count
def breaking(G):
to_remove = []
max_breaking = 2
breaking_vertex = None
for i in range(len(G)):
for j in range(len(G)):
if G[i][j] != 0:
to_remove.append(j)
for k in range(len(to_remove)):
G[i][to_remove[k]] = G[to_remove[k]][i] = 0
actual_break = components(G)
if actual_break > max_breaking:
max_breaking = actual_break
breaking_vertex = i
for k in range(len(to_remove)):
G[i][to_remove[k]] = G[to_remove[k]][i] = 1
to_remove.clear()
return breaking_vertex
runtests(breaking)
# Rozwiązanie należy zaimplementować w postaci funkcji:
# def cutthetree(T):
# ...
# która przyjmuje korzeń danego drzewa BST i zwraca wartość rozwiązania. Nie wolno zmieniać definicji
# class BNode.
from Exercise_2_tests import runtests
from math import inf
class BNode:
def __init__(self, value):
self.left = None
self.right = None
self.parent = None
self.value = value
def cutthetree(T):
if T is None:
return 0
if T.right is None and T.left is None:
return inf
actual_value = inf
if T.parent is not None:
actual_value = T.value
actual_value = min(actual_value, cutthetree(T.right) + cutthetree(T.left))
return actual_value
runtests(cutthetree)
def count_sum_of_edges(T):
for e in T.edges:
count_sum_of_edges(e)
for i in range(len(T.edges)):
T.sum_of_edges += T.weights[i] + T.edges[i].sum_of_edges
def find_best_edge(root, node, best_index, best_diff):
for i in range(len(node.edges)):
actual_index, actual_diff = find_best_edge(root, node.edges[i],
best_index, best_diff)
root_subtree = root.sum_of_edges - node.edges[
i].sum_of_edges - node.weights[i]
node_subtree = node.edges[i].sum_of_edges
if actual_diff < best_diff:
best_diff = actual_diff
best_index = actual_index
if abs(root_subtree - node_subtree) < best_diff:
best_diff = abs(root_subtree - node_subtree)
best_index = node.ids[i]
return best_index, best_diff
def balance(T):
count_sum_of_edges(T)
best_index, best_diff = find_best_edge(T, T, None, inf)
return best_index
runtests(balance)
is_sorted = None
actual = head
while actual is not None:
nex_node = actual.next
is_sorted = sorted_insert(is_sorted, actual)
actual = nex_node
head = is_sorted
return head
def sorted_insert(head, new_node):
if head is None or head.val >= new_node.val:
new_node.next = head
head = new_node
else:
actual = head
while actual.next is not None and actual.next.val < new_node.val:
actual = actual.next
new_node.next = actual.next
actual.next = new_node
return head
def SortH(p, k):
if k == 0:
return p
return insertion_sort(p)
runtests(SortH)
def recursion(L, K, T, result, idx):
if len(result) == len(T):
return True
for j in range(len(T)):
if result[idx] % (10 ** K) == T[j][0] // (10 ** K) and not T[j][1]:
result.append(T[j][0])
T[j][1] = True
recursion(L, K, T, result, idx + 1)
if len(result) != len(T):
idx -= 1
value = result.pop()
T[L.index(value)][1] = False
def order(L, K):
start = min(L)
T = [0] * len(L)
for i in range(len(T)):
if L[i] == start:
T[i] = [L[i], True]
else:
T[i] = [L[i], False]
result = [start]
recursion(L, K, T, result, 0)
return result
runtests(order)