input: Write a python function to create a Huffman tree and draw it using pydot, given symbols and their frequencies.
  assert generate_huffman_tree(['A', 'B', 'C', 'D', 'E', 'F'], [45, 13, 12, 16, 9, 5]) == 'HuffmanTree.png'
  assert generate_huffman_tree(['G', 'H', 'I', 'J'], [25, 30, 20, 25]) == 'HuffmanTree.png'
  assert generate_huffman_tree(['K', 'L', 'M'], [10, 50, 40]) == 'HuffmanTree.png'
output: import heapq
  import pydot
  
  class Node:
      def __init__(self, symbol, freq):
          self.symbol = symbol
          self.freq = freq
          self.left = None
          self.right = None
  
      def __lt__(self, other):
          return self.freq < other.freq
  
  def generate_huffman_tree(symbols, frequencies):
      # Step 1: Create a priority queue (min-heap) with nodes
      heap = [Node(symbols[i], frequencies[i]) for i in range(len(symbols))]
      heapq.heapify(heap)
  
      # Step 2: Build the Huffman tree
      while len(heap) > 1:
          node1 = heapq.heappop(heap)
          node2 = heapq.heappop(heap)
          merged = Node(None, node1.freq + node2.freq)
          merged.left = node1
          merged.right = node2
          heapq.heappush(heap, merged)
  
      # The root of the tree
      root = heap[0]
  
      # Step 3: Generate the graph
      graph = pydot.Dot(graph_type='graph')
  
      def add_edges(node, graph, parent_name=None):
          if node is not None:
              node_name = str(id(node))
              label = node.symbol if node.symbol is not None else ''
              graph.add_node(pydot.Node(node_name, label=f"{label}\n{node.freq}"))
  
              if parent_name is not None:
                  graph.add_edge(pydot.Edge(parent_name, node_name))
  
              add_edges(node.left, graph, node_name)
              add_edges(node.right, graph, node_name)
  
      add_edges(root, graph)
  
      # Save the graph to a file
      output_file = 'HuffmanTree.png'
      graph.write_png(output_file)
  
      return output_file