




_UpperCAmelCase	:						dict[tuple[int, int, int], int]			=     {}



def       UpperCAmelCase__  (     lowerCamelCase,			lowerCamelCase,			lowerCamelCase   ):

  # if we are absent twice, or late 3 consecutive days,
  # no further prize strings are possible
  if late == 3 or absent == 2:
    return 0

  # if we have no days left, and have not failed any other rules,
  # we have a prize string
  if days == 0:
    return 1

  # No easy solution, so now we need to do the recursive calculation

  # First, check if the combination is already in the cache, and
  # if yes, return the stored value from there since we already
  # know the number of possible prize strings from this point on
  lowercase    :int      	=						(days, absent, late)
  if key in cache:
    return cache[key]

  # now we calculate the three possible ways that can unfold from
  # this point on, depending on our attendance today

  # 1) if we are late (but not absent), the "absent" counter stays as
  # it is, but the "late" counter increases by one
  lowercase    :Any      	=						_calculate(days - 1,			lowerCamelCase,			late + 1   )

  # 2) if we are absent, the "absent" counter increases by 1, and the
  # "late" counter resets to 0
  lowercase    :Any      	=						_calculate(days - 1,			absent + 1,			0   )

  # 3) if we are on time, this resets the "late" counter and keeps the
  # absent counter
  lowercase    :Optional[Any]      	=						_calculate(days - 1,			lowerCamelCase,			0   )

  lowercase    :Optional[Any]      	=						state_late + state_absent + state_ontime

  lowercase    :Union[str, Any]      	=						prizestrings
  return prizestrings



def       UpperCAmelCase__  (     lowerCamelCase = 30   ):
  return _calculate(lowerCamelCase,			absent=0,			late=0   )


if __name__ == "__main__":
     print(solution())









from collections import defaultdict

from graphs.minimum_spanning_tree_prims import prisms_algorithm as mst



def       UpperCAmelCase__  (     ):
  lowercase	,    lowercase    :Union[str, Any]      	=						9, 14  # noqa: F841
  lowercase    :Optional[Any]      	=						[
      [0, 1, 4],
      [0, 7, 8],
      [1, 2, 8],
      [7, 8, 7],
      [7, 6, 1],
      [2, 8, 2],
      [8, 6, 6],
      [2, 3, 7],
      [2, 5, 4],
      [6, 5, 2],
      [3, 5, 14],
      [3, 4, 9],
      [5, 4, 10],
      [1, 7, 11],
  ]

  lowercase    :Optional[Any]      	=						defaultdict(lowerCamelCase   )
  for nodea, nodea, cost in edges:
    adjancency[nodea].append([nodea, cost]   )
    adjancency[nodea].append([nodea, cost]   )

  lowercase    :Optional[int]      	=						mst(lowerCamelCase   )

  lowercase    :Any      	=						[
      [7, 6, 1],
      [2, 8, 2],
      [6, 5, 2],
      [0, 1, 4],
      [2, 5, 4],
      [2, 3, 7],
      [0, 7, 8],
      [3, 4, 9],
  ]

  for answer in expected:
    lowercase    :Any      	=						tuple(answer[:2]   )
    lowercase    :str      	=						tuple(edge[::-1]   )
    assert edge in result or reverse in result



