code: 
  
  """simple docstring"""
  
  
  
  
  from __future__ import annotations
  
  
  
  
  
  class     __UpperCamelCase				:
  
  
  		def __init__(self				:	Tuple  ,  __SCREAMING_SNAKE_CASE				:	int):
  							A    =      vertices
  							A    =      [[0] * vertices for _ in range(__SCREAMING_SNAKE_CASE)]
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	List[str]  ,  __SCREAMING_SNAKE_CASE				:	list[int]):
  							print("Vertex \t Distance from Source")
  							for vertex in range(self.vertices):
  												print(__SCREAMING_SNAKE_CASE  ,  "\t\t"  ,  distances_from_source[vertex])
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	str  ,  __SCREAMING_SNAKE_CASE				:	list[int]  ,  __SCREAMING_SNAKE_CASE				:	list[bool]):
  							A    =      1E7
  							A    =      0
  
  							# Search not nearest vertex not in the shortest path tree
  							for vertex in range(self.vertices):
  												if distances_from_source[vertex] < minimum and visited[vertex] is False:
  																	A    =      distances_from_source[vertex]
  																	A    =      vertex
  							return min_index
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	Dict  ,  __SCREAMING_SNAKE_CASE				:	int):
  							A    =      [int(1E7)] * self.vertices  # distances from the source
  							A    =      0
  							A    =      [False] * self.vertices
  
  							for _ in range(self.vertices):
  												A    =      self.minimum_distance(__SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE)
  												A    =      True
  
  												# Update dist value of the adjacent vertices
  												# of the picked vertex only if the current
  												# distance is greater than new distance and
  												# the vertex in not in the shortest path tree
  												for v in range(self.vertices):
  																	if (
  																	    self.graph[u][v] > 0
  																	    and visited[v] is False
  																	    and distances[v] > distances[u] + self.graph[u][v]
  																	):
  																						A    =      distances[u] + self.graph[u][v]
  
  							self.print_solution(__SCREAMING_SNAKE_CASE)
  
  
  if __name__ == "__main__":
  	__A  :					List[Any]												=	Graph(9)
  	__A  :					List[str]												=	[
  	    [0, 4, 0, 0, 0, 0, 0, 8, 0],
  	    [4, 0, 8, 0, 0, 0, 0, 11, 0],
  	    [0, 8, 0, 7, 0, 4, 0, 0, 2],
  	    [0, 0, 7, 0, 9, 14, 0, 0, 0],
  	    [0, 0, 0, 9, 0, 10, 0, 0, 0],
  	    [0, 0, 4, 14, 10, 0, 2, 0, 0],
  	    [0, 0, 0, 0, 0, 2, 0, 1, 6],
  	    [8, 11, 0, 0, 0, 0, 1, 0, 7],
  	    [0, 0, 2, 0, 0, 0, 6, 7, 0],
  	]
  	graph.dijkstra(0)
  
  
  
  
  
  
style_context: 
  
  """simple docstring"""
  
  
  
  
  import functools
  from math import sqrt
  from time import time
  def      __SCREAMING_SNAKE_CASE		(		lowercase__    ,							*lowercase__    ,							**lowercase__   ):
  					"""simple docstring"""
  					A    =      time()
  					A    =      func(*lowercase__    ,							**lowercase__   )
  					A    =      time()
  					if int(end - start   ) > 0:
  										print(F"""{func.__name__} runtime: {(end - start):0.4f} s"""   )
  					else:
  										print(F"""{func.__name__} runtime: {(end - start) * 1_000:0.4f} ms"""   )
  					return output
  def      __SCREAMING_SNAKE_CASE		(		lowercase__   ):
  					"""simple docstring"""
  					if n < 0:
  										raise Exception("n is negative"   )
  					if n == 0:
  										return [0]
  					A    =      [0, 1]
  					for _ in range(n - 1   ):
  										fib.append(fib[-1] + fib[-2]   )
  					return fib
  def      __SCREAMING_SNAKE_CASE		(		lowercase__   ):
  					"""simple docstring"""
  
  					def fib_recursive_term(lowercase__   ) -> int:
  										if i < 0:
  															raise Exception("n is negative"   )
  										if i < 2:
  															return i
  										return fib_recursive_term(i - 1   ) + fib_recursive_term(i - 2   )
  
  					if n < 0:
  										raise Exception("n is negative"   )
  					return [fib_recursive_term(lowercase__   ) for i in range(n + 1   )]
  def      __SCREAMING_SNAKE_CASE		(		lowercase__   ):
  					"""simple docstring"""
  
  					@functools.cache
  					def fib_recursive_term(lowercase__   ) -> int:
  										if i < 0:
  															raise Exception("n is negative"   )
  										if i < 2:
  															return i
  										return fib_recursive_term(i - 1   ) + fib_recursive_term(i - 2   )
  
  					if n < 0:
  										raise Exception("n is negative"   )
  					return [fib_recursive_term(lowercase__   ) for i in range(n + 1   )]
  def      __SCREAMING_SNAKE_CASE		(		lowercase__   ):
  					"""simple docstring"""
  					if n < 0:
  										raise Exception("n is negative"   )
  					# Cache must be outside recursuive function
  					# other it will reset every time it calls itself.
  					A    =      {0: 0, 1: 1, 2: 1}  # Prefilled cache
  
  					def rec_fn_memoized(lowercase__   ) -> int:
  										if num in cache:
  															return cache[num]
  
  										A    =      rec_fn_memoized(num - 1   ) + rec_fn_memoized(num - 2   )
  										A    =      value
  										return value
  
  					return [rec_fn_memoized(lowercase__   ) for i in range(n + 1   )]
  def      __SCREAMING_SNAKE_CASE		(		lowercase__   ):
  					"""simple docstring"""
  					if n < 0:
  										raise Exception("n is negative"   )
  					if n >= 1_475:
  										raise Exception("n is too large"   )
  					A    =      sqrt(5   )
  					A    =      (1 + sqrt_a) / 2
  					return [round(phi**i / sqrt_a   ) for i in range(n + 1   )]
  
  
  if __name__ == "__main__":
  	__A  :					Optional[Any]												=	30
  	time_func(fib_iterative, num)
  	time_func(fib_recursive, num)  # Around 3s runtime
  	time_func(fib_recursive_cached, num)  # Around 0ms runtime
  	time_func(fib_memoization, num)
  	time_func(fib_binet, num)
  
  
  
  
  
  