input: Write a python function to divide a list into three groups with equal sums.
  assert divide_list_into_equal_groups([3, 3, 3, 3, 3, 3]) == ([3, 3], [3, 3], [3, 3])
  assert divide_list_into_equal_groups([1, 2, 3, 4, 5, 6]) == ([1, 2, 3], [4], [5, 6])
  assert divide_list_into_equal_groups([1, 1, 1, 1, 1, 1]) == ([1, 1], [1, 1], [1, 1])
  assert divide_list_into_equal_groups([1, 2, 3, 4, 5]) == -1
output: def divide_list_into_equal_groups(lst):
      def can_partition(nums, k):
          total_sum = sum(nums)
          if total_sum % k != 0:
              return False
          target = total_sum // k
          nums.sort(reverse=True)
          groups = [0] * k
  
          def backtrack(i):
              if i == len(nums):
                  return len(set(groups)) == 1
              for j in range(k):
                  if groups[j] + nums[i] <= target:
                      groups[j] += nums[i]
                      if backtrack(i + 1):
                          return True
                      groups[j] -= nums[i]
                  if groups[j] == 0:
                      break
              return False
  
          return backtrack(0)
  
      if can_partition(lst, 3):
          lst.sort(reverse=True)
          target_sum = sum(lst) // 3
          groups = [[] for _ in range(3)]
          group_sums = [0] * 3
  
          def backtrack(i):
              if i == len(lst):
                  return group_sums[0] == group_sums[1] == group_sums[2]
              for j in range(3):
                  if group_sums[j] + lst[i] <= target_sum:
                      group_sums[j] += lst[i]
                      groups[j].append(lst[i])
                      if backtrack(i + 1):
                          return True
                      group_sums[j] -= lst[i]
                      groups[j].pop()
                  if group_sums[j] == 0:
                      break
              return False
  
          if backtrack(0):
              return tuple(groups)
      return -1