distance = [inf] * len(graph)
visited = [False] * len(graph)
distance[source] = 0
while not queue.empty():
dist, u = queue.get()
for v in graph[u]:
if not visited[v[0]] and relax(u, v, distance):
queue.put((dist + v[1], v[0]))
visited[u] = True
return distance
def paths(G, s, t):
edges = []
for i in range(len(G)):
for j in range(len(G[i])):
edges.append((i, G[i][j][0], G[i][j][1]))
distance_from_s = dijkstra_algorithm(G, s)
distance_from_t = dijkstra_algorithm(G, t)
count = 0
if distance_from_s[t] == inf or distance_from_t[s] == inf:
return 0
for i in range(len(edges)):
if (distance_from_s[edges[i][0]] + distance_from_t[edges[i][1]] + edges[i][2] == distance_from_s[t] or
distance_from_s[edges[i][0]] + distance_from_t[edges[i][1]] + edges[i][2] == distance_from_t[s]):
count += 1
return count
runtests(paths)
if T[new_row[i]][new_col[i]] != 0:
take_fuel(T, new_row[i], new_col[i], actual_fuel)
def plan(T):
stops = []
limit = len(T[0])
actual_fuel = [0]
i = 0
while i < limit:
if T[0][i] != 0:
actual_fuel[0] = 0
take_fuel(T, 0, i, actual_fuel)
T[0][i] = actual_fuel[0]
i += 1
queue = PriorityQueue()
total_fuel = 0
for i in range(limit - 1):
if T[0][i] != 0:
queue.put((-T[0][i], i))
if total_fuel == 0:
actual_value = queue.get()
total_fuel -= actual_value[0]
stops.append(actual_value[1])
total_fuel -= 1
stops.sort()
return stops
runtests(plan)
def Floyd_Warshall_algorithm(graph):
distance = [[inf] * len(graph) for _ in range(len(graph))]
for i in range(len(distance)):
for j in range(len(distance)):
if i == j:
distance[i][j] = 0
elif graph[i][j] != 0:
distance[i][j] = graph[i][j]
for k in range(len(graph)):
for u in range(len(graph)):
for v in range(len(graph)):
distance[u][v] = min(distance[u][v],
distance[u][k] + distance[k][v])
return distance
def BlueAndGreen(T, K, D):
graph = [[0] * (len(T) + 2) for _ in range(len(T) + 2)]
distance = Floyd_Warshall_algorithm(T)
for i in range(len(T)):
for j in range(len(T)):
if distance[i][j] >= D and distance[i][j] != inf:
if K[i] == 'B' and K[j] == 'G':
graph[i][j] = graph[j][len(T) + 1] = graph[len(T)][i] = 1
return edmonds_karp(graph, len(T), len(T) + 1)
runtests(BlueAndGreen)
for j in range(len(buckets[i])):
buckets[i][j] = insertion_sort(buckets[i][j])
idx = 0
for i in range(len(buckets)):
for j in range(len(buckets[i])):
for k in range(len(buckets[i][j])):
T[idx] = buckets[i][j][k]
idx += 1
return T
def SortTab(T, P):
buckets = [[] for _ in range(len(P))]
for i in range(len(T)):
for j in range(len(P)):
if T[i] > P[j][0] and T[i] < P[j][1]:
buckets[j].append(T[i])
max_min = []
for i in range(len(buckets)):
minimum = min(buckets[i])
maximum = max(buckets[i])
max_min.append((minimum, maximum))
new_buckets = []
for i in range(len(P)):
array = [[] for _ in range(len(buckets[i]))]
new_buckets.append(array)
bucket_sort(T, new_buckets, max_min)
runtests(SortTab)
def kintersect(A, k):
interval = [(i, A[i][0], A[i][1]) for i in range(len(A))]
interval.sort(key=lambda x: x[2], reverse=True)
max_length = 0
if k == 1:
result = [0]
for i in range(len(A)):
if interval[i][2] - interval[i][1] > max_length:
max_length = interval[i][2] - interval[i][1]
result[0] = interval[i][0]
return result
result = []
for i in range(len(A)):
current = [interval[i][0]]
for j in range(len(A)):
if i != j and interval[j][1] <= interval[i][1] < interval[j][2]:
current.append(interval[j][0])
if len(current) == k:
actual_length = min(interval[j][2] - interval[i][1],
interval[i][2] - interval[i][1])
if actual_length > max_length:
max_length = actual_length
result.clear()
result = [current[i] for i in range(k)]
break
return result
runtests(kintersect)
# i ma jeden przełącznik, który zmienia jej kolor (z zielonego na czerwony, z czerwonego na niebieski
# i z niebieskiego na zielony). Początkowo wszystkie lampki świecą na zielono. Operacja (a, b) oznacza
# "wciśnięcie przełącznika na każdej z lampek o numerach od a do b". Wykonanych będzie m operacji.
# Proszę napisać funkcję:
# def lamps(n, L):
# ...
# która mając daną liczbę n lampek oraz listę L operacji (wykonywanych w podanej kolejności) zwraca
# ile maksymalnie lampek świeciło się na niebiesko (lampki są liczone na początku i po wykonaniu
# każdej operacji).
from Exercise_3_tests import runtests
def lamps(n, T):
all_lamps = [0] * n
max_blue = actual_blue = 0
for i in range(len(T)):
for j in range(T[i][0], T[i][1] + 1):
if all_lamps[j] == 0:
all_lamps[j] = 1
elif all_lamps[j] == 1:
all_lamps[j] = 2
actual_blue += 1
elif all_lamps[j] == 2:
all_lamps[j] = 0
actual_blue -= 1
max_blue = max(max_blue, actual_blue)
return max_blue
runtests(lamps)
if DP[i][j] != inf:
actual = V[i] + j
if actual > q:
actual = q
for k in range(i + 1, len(T)):
if relax(DP, T, parent, actual, i, j, k):
continue
else:
break
best = inf
index = None
for i in range(q + 1):
if DP[len(T) - 1][i] < best:
best = DP[len(T) - 1][i]
index = i
result = []
if best == inf:
return result
i = len(T) - 1
p = inf
while p != 0:
p = parent[i][index][0]
result.append(p)
index = parent[i][index][1]
i = p
result.reverse()
return result
runtests(iamlate)