from __future__ import annotations

import random

# Adjacency list representation of this graph:
# https://en.wikipedia.org/wiki/File:Single_run_of_Karger%E2%80%99s_Mincut_algorithm.svg
lowerCAmelCase__							= {
    '1': ['2', '3', '4', '5'],
    '2': ['1', '3', '4', '5'],
    '3': ['1', '2', '4', '5', '10'],
    '4': ['1', '2', '3', '5', '6'],
    '5': ['1', '2', '3', '4', '7'],
    '6': ['7', '8', '9', '10', '4'],
    '7': ['6', '8', '9', '10', '5'],
    '8': ['6', '7', '9', '10'],
    '9': ['6', '7', '8', '10'],
    '10': ['6', '7', '8', '9', '3'],
}






def       __lowerCamelCase		(						lowerCAmelCase__	):
       lowerCAmelCase__     	=					{node: {node} for node in graph}

       lowerCAmelCase__     	=					{node: graph[node][:] for node in graph}

       while len(lowerCAmelCase__	) > 2:
              # Choose a random edge.
              lowerCAmelCase__     	=					random.choice(list(graph_copy.keys()	)	)
              lowerCAmelCase__     	=					random.choice(graph_copy[u]	)

              # Contract edge (u, v) to new node uv
              lowerCAmelCase__     	=					u + v
              lowerCAmelCase__     	=					list(set(graph_copy[u] + graph_copy[v]	)	)
              uv_neighbors.remove(lowerCAmelCase__	)
              uv_neighbors.remove(lowerCAmelCase__	)
              lowerCAmelCase__     	=					uv_neighbors
              for neighbor in uv_neighbors:
                     graph_copy[neighbor].append(lowerCAmelCase__	)

              lowerCAmelCase__     	=					set(contracted_nodes[u].union(contracted_nodes[v]	)	)

              # Remove nodes u and v.
              del graph_copy[u]
              del graph_copy[v]
              for neighbor in uv_neighbors:
                     if u in graph_copy[neighbor]:
                            graph_copy[neighbor].remove(lowerCAmelCase__	)
                     if v in graph_copy[neighbor]:
                            graph_copy[neighbor].remove(lowerCAmelCase__	)

              # Find cutset.
       lowerCAmelCase__     	=					[contracted_nodes[node] for node in graph_copy]
       return {
           (node, neighbor)
           for node in groups[0]
           for neighbor in graph[node]
           if neighbor in groups[1]
       }


if __name__ == "__main__":
    print(partition_graph(TEST_GRAPH))







def 			lowerCamelCase_		(					lowerCAmelCase:		str			,							lowerCAmelCase:		str )->						int:
  # The longer word should come first
  if len(lowerCAmelCase ) < len(lowerCAmelCase ):
    return levenshtein_distance(lowerCAmelCase			,							lowerCAmelCase )

  if len(lowerCAmelCase ) == 0:
    return len(lowerCAmelCase )

  _snake_case      : Dict														=		list(range(len(lowerCAmelCase ) + 1 ) )

  for i, ca in enumerate(lowerCAmelCase ):
    _snake_case      : Optional[int]														=		[i + 1]

    for j, ca in enumerate(lowerCAmelCase ):
      # Calculate insertions, deletions and substitutions
      _snake_case      : Optional[Any]														=		previous_row[j + 1] + 1
      _snake_case      : Optional[int]														=		current_row[j] + 1
      _snake_case      : Union[str, Any]														=		previous_row[j] + (ca != ca)

      # Get the minimum to append to the current row
      current_row.append(min(lowerCAmelCase			,							lowerCAmelCase			,							lowerCAmelCase ) )

    # Store the previous row
    _snake_case      : str														=		current_row

  # Returns the last element (distance)
  return previous_row[-1]


if __name__ == "__main__":
      lowerCAmelCase_        =			input("""Enter the first word:\n""").strip()
      lowerCAmelCase_        =			input("""Enter the second word:\n""").strip()

      lowerCAmelCase_        =			levenshtein_distance(first_word, second_word)
      print(F"""Levenshtein distance between {first_word} and {second_word} is {result}""")




