

# A Bipartite Graph is a graph whose vertices can be divided into two independent sets,
# U and V such that every edge (u, v) either connects a vertex from U to V or a vertex
# from V to U. In other words, for every edge (u, v), either u belongs to U and v to V,
# or u belongs to V and v to U. We can also say that there is no edge that connects
# vertices of same set.
from queue import Queue

def 			__snake_case		(   __UpperCamelCase  :   Dict						):



      """simple docstring"""

      A_	     =							Queue()
      A_	     =							[False] * len(__UpperCamelCase						)
      A_	     =							[-1] * len(__UpperCamelCase						)

      def bfs():
            while not queue.empty():
                  A_	     =							queue.get()
                  A_	     =							True

                  for neighbour in graph[u]:
                        if neighbour == u:
                              return False

                        if color[neighbour] == -1:
                              A_	     =							1 - color[u]
                              queue.put(__UpperCamelCase						)

                        elif color[neighbour] == color[u]:
                              return False

            return True

      for i in range(len(__UpperCamelCase						)						):
            if not visited[i]:
                  queue.put(__UpperCamelCase						)
                  A_	     =							0
                  if bfs() is False:
                        return False

      return True


if __name__ == "__main__":
      # Adjacency List of graph
      print(check_bipartite({0: [1, 3], 1: [0, 2], 2: [1, 3], 3: [0, 2]}))


def 			__snake_case	(   __UpperCamelCase  :   str						):



      """simple docstring"""

      A_	     =							len(__UpperCamelCase						)
      A_	     =							[0] * length
      A_	     =							[[False for i in range(__UpperCamelCase						)] for j in range(__UpperCamelCase						)]
      for i, c in enumerate(__UpperCamelCase						):
            A_	     =							i
            for j in range(i + 1						):
                  if c == string[j] and (i - j < 2 or is_palindromic[j + 1][i - 1]):
                        A_	     =							True
                        A_	     =							min(__UpperCamelCase							,0 if j == 0 else (cut[j - 1] + 1)						)
            A_	     =							mincut
      return cut[length - 1]


if __name__ == "__main__":
      __a						:Union[str, Any]            = input('Enter the string: ').strip()
      __a						:Tuple            = find_minimum_partitions(s)
      print(F"Minimum number of partitions required for the '{s}' is {ans}")