Алгоритмы сжатия попыток набора

У меня есть набор наборов, которые я хотел бы поместить в дерево .

Обычные попытки состоят из цепочек элементов, то есть порядок элементов важен. В наборах отсутствует определенный порядок, поэтому существует вероятность большего сжатия.

Например, для строк «abc» , «bc» и «c» я бы создал дерево:

(*,3) -> ('a',1) -> ('b',1) -> ('c',1)
      -> ('b',1) -> ('c',1)
      -> ('c',1)

Но учитывая наборы {'a', 'b', 'c'} , {'b', 'c'} , {'c'} , Я мог бы создать приведенное выше дерево или любое из этих одиннадцати:

(*,3) -> ('a',1) -> ('b',1) -> ('c',1)
      -> ('c',2) -> ('a',1)

(*,3) -> ('a',1) -> ('c',1) -> ('b',1)
      -> ('b',1) -> ('c',1)
      -> ('c',1)

(*,3) -> ('a',1) -> ('c',1) -> ('b',1)
      -> ('c',2) -> ('a',1)

(*,3) -> ('b',2) -> ('a',1) -> ('c',1)
                 -> ('c',1)
      -> ('c',1)

(*,3) -> ('b',1) -> ('a',1) -> ('c',1)
      -> ('c',2) -> ('b',1)

(*,3) -> ('b',2) -> ('c',2) -> ('a',1)
      -> ('c',1)

(*,3) -> ('b',1) -> ('c',1) -> ('a',1)
      -> ('c',2) -> ('b',1)

(*,3) -> ('c',2) -> ('a',1) -> ('b',1)
      -> ('b',1) -> ('c',1)

(*,3) -> ('c',2) -> ('a',1) -> ('b',1)
                 -> ('b',1)

(*,3) -> ('c',2) -> ('b',1) -> ('a',1)
      -> ('b',1) -> ('c',1)

(*,3) -> ('c',3) -> ('b',2) -> ('a',1)

Итак, очевидно, есть место для сжатия (с 7 узлов до 4).

Я подозреваю, что определение локального порядка на каждом узле в зависимости от относительной частоты его дочерних узлов сделает это, но я не уверен, и это может быть слишком дорого.

Итак, прежде чем я коснусь доски и начну ломать голову над своим собственным алгоритмом сжатия, существует ли какой-либо алгоритм? Насколько это дорого? Это массовый процесс или его можно выполнять при вставке / удалении?